macro.sus_class_trivially_relocatable_if.html

<!DOCTYPE html>
<html>
  <head>
    <meta content="text/html;charset=utf-8" http-equiv="Content-Type"></meta>
    <meta name="generator" content="subdoc"></meta>
    <meta name="viewport" content="width=device-width, initial-scale=1"></meta>
    <meta property="og:type" content="website"></meta>
    <meta property="og:site_name" content="Subspace"></meta>
    <meta property="og:url" content="https://suslib.cc/macro.sus_class_trivially_relocatable_if.html"></meta>
    <title>sus_class_trivially_relocatable_if - Subspace</title>
    <meta property="og:title" content="sus_class_trivially_relocatable_if - Subspace"></meta>
    <meta name="description" content="Mark a class as trivially relocatable based on a compile-time condition."></meta>
    <meta property="og:description" content="Mark a class as trivially relocatable based on a compile-time condition."></meta>
    <script src="https://unpkg.com/lunr/lunr.js"></script>
    <script src="./search_db.js"></script>
    <script>
      
        // Delayed loading of whatever was in the search box.
        var searchDelayLoad;

        // The search box's dynamic behaviour.
        document.addEventListener("keyup", e => {
          if (e.key === 's') {
            document.querySelector('.search-input').focus();
          }
          if (e.key === 'Escape') {
            document.querySelector('.search-input').blur();
            navigateToSearch(null);
            e.preventDefault();
          }
        });
        function navigateToSearch(query) {
          window.clearTimeout(searchDelayLoad);
          searchDelayLoad = null;

          let without_search =
              window.location.origin + window.location.pathname;
          if (query) {
            window.history.replaceState(null, "",
              without_search + "?" + `search=${query}`);
          } else {
            window.history.replaceState(null, "", without_search);
          }
          maybeShowSearchResults();
        }
        addEventListener("load", event => {
          document.querySelector(".search-input").oninput = (e) => {
            window.clearTimeout(searchDelayLoad);
            searchDelayLoad = window.setTimeout(() => {
              navigateToSearch(e.target.value);
            }, 1000);
          };
          document.querySelector(".search-input").onkeypress = (e) => {
            if (e.key == "Enter") {
              navigateToSearch(e.target.value);
              e.preventDefault();
            }
          };
          var searchPlaceholder;
          document.querySelector(".search-input").onfocus = (e) => {
            searchPlaceholder = e.target.placeholder;
            e.target.placeholder = "Type your search here.";
            navigateToSearch(e.target.value);
          };
          document.querySelector(".search-input").onblur = (e) => {
            e.target.placeholder = searchPlaceholder;
            searchPlaceholder = null;
          };
        });

        // Show or hide any DOM element.
        function showHide(selector, show) {
          if (show)
            document.querySelector(selector).classList.remove("hidden");
          else
            document.querySelector(selector).classList.add("hidden");
        }

        function searchQuery() {
          const params = new Proxy(
            new URLSearchParams(window.location.search), {
              get: (searchParams, prop) => searchParams.get(prop),
            }
          );
          return params.search;
        }

        // Showing search results.
        async function populateSearchResults(loaded) {
          const search_db = loaded.search_db;
          const idx = loaded.idx;

          // lunrjs treats `:` specially and `::` breaks the query syntax, so
          // just split into two words.
          const query = searchQuery().split("::").join(" ");
          let content = '';
          try {
            const results = idx.search(query);
            for (r of results) {
              const item = search_db[r.ref];

              const type = item.type;
              const url = item.url;
              const name = item.name;
              const full_name = item.full_name;
              const summmary = item.summary ? item.summary : "";

              content += `\
                <a class="search-results-link" href="${url}">
                  <span class="search-results-type"><div>${type}</div></span>\
                  <span class="search-results-name"><div>${full_name}</div></span>\
                  <span class="search-results-summary"><div>${summmary}</div></span>\
                </a>\
                `
            }
          } catch (err) {
            content +=
                `<div class="search-error">Search error: ${err.message}</div>`;
          }

          let content_elem = document.querySelector(".search-results-content");
          content_elem.innerHTML = content;

          let header_elem = document.querySelector(".search-results-header");
          header_elem.innerText = "Search results";
        }

        var cache_idx;

        // Searching via https://lunrjs.com.
        //
        // Load the JSON search database, which will be turned into a search
        // index. Returns an object with two fields:
        // - search_db: the contents of the search.json file.
        // - idx: the lunr search index.
        //   Documented at https://lunrjs.com/docs/lunr.Index.html.
        async function loadSearchIndex() {
          // This is not widely supported yet (not on Safari), so instead we
          // turned the json file into a js file that sets a global variable. :|
          //async function load_search_db() {
          //  let x = await import('./search.json', {
          //    with: {type: 'json'}
          //  });
          //  return x.default;
          //}

          async function load_idx(search_db) {
            let idx = lunr(function () {
              this.ref('index');
              this.field('name', {
                'boost': 2,
                editDistance: 0
              });
              this.field('full_name', {
                'boost': 2,
                editDistance: 2
              });
              this.field('split_name', {
                'boost': 0.5,
                editDistance: 2
              });

              // No stemming and no stopwords (like `into` and `from`).
              this.pipeline = new lunr.Pipeline();
              this.searchPipeline = new lunr.Pipeline();

              // Queries are split by these tokens.
              const splitBy = /(\s+|_+|(::)+)/
              this.use(builder => {
                function splitTokens(token) {
                  return token.toString().split(splitBy).map(str => {
                    return token.clone().update(() => { return str })
                  })
                }
                lunr.Pipeline.registerFunction(splitTokens, 'splitTokens')
                builder.searchPipeline.add(splitTokens)
              });

              search_db.forEach(item => {
                const weights = {
                  "concept": 3,
                  "class": 2,
                  "struct": 2,
                  "union": 2,
                  "function": 1.75,
                  "variable": 1.75,
                  "namespace": 1.2,
                  "method": 1,
                  "constructor": 1,
                  "macro": 1,
                  "project": 1,
                  "field": 0.9,
                  "conversion": 0.5,
                  "type alias": 0.5,
                  "concept alias": 0.5,
                  "function alias": 0.5,
                  "method alias": 0.5,
                  "enum value alias": 0.5,
                  "variable alias": 0.5,
                }
                let weight = weights[item.type];
                if (!weight) {
                  console.log(`WARNING: search item type ${item.type} ` +
                              `has no weight defined`);
                  weight = 1;
                }
                this.add(item, {
                  'boost': weight
                })
              }, this);
            });
            let out = {};
            out.search_db = search_db;
            out.idx = idx;
            return out;
          };

          if (!cache_idx) {
            cache_idx = await load_idx(g_search_db);
          }
          return cache_idx;
        }

        // If there's a search query, hide the other content and asynchronously
        // show the search results. Otherwise, hide search content and show the
        // rest immediately.
        function maybeShowSearchResults() {
          const query = searchQuery();
          if (query) {
            showHide(".main-content", false);

            let input = document.querySelector(".search-input");
            input.value = query;

            let header_elem = document.querySelector(".search-results-header");
            header_elem.innerText = "Loading search results...";

            let content_ele = document.querySelector(".search-results-content");
            content_ele.innerText = "";

            loadSearchIndex().then(populateSearchResults)
          } else {
            showHide(".main-content", true);

            let header_elem = document.querySelector(".search-results-header");
            header_elem.innerText = "";

            let content_ele = document.querySelector(".search-results-content");
            content_ele.innerText = "";
          }
        }

        
    </script>
    <link rel="stylesheet" href="subdoc-test-style.css">
    <link rel="icon" type="image/png" href="logo.png">
    <link rel="alternate icon" type="image/png" href="logo32.png">
    <meta property="og:image" content="logo.png"></meta>
  </head>

  <body>
    <nav class="topbar">
      <button class="sidebar-menu-button" onclick="let e = document.getElementsByClassName('sidebar')[0];e.classList.toggle('shown');">
        ☰
      </button>
      <a class="topbar-logo-link" href="index.html"><div class="topbar-logo-border">
          <img class="topbar-logo" src="logo.png"></img>
        </div></a>
      <span class="topbar-text-area">
        <span class="topbar-title">
          <a href="#">sus_class_trivially_relocatable_if</a>
        </span>
      </span>
    </nav>
    <nav class="sidebar">
      <a class="sidebar-logo-link" href="index.html"><div class="sidebar-logo-border">
          <img class="sidebar-logo" src="logo.png"></img>
        </div></a>
      <div class="sidebar-pretitle sidebar-text">
        macro
      </div>
      <div class="sidebar-title sidebar-text">
        <a href="#">sus_class_trivially_relocatable_if</a>
      </div>
      <div class="sidebar-subtitle sidebar-text">
      </div>
      <div class="sidebar-links sidebar-text">
        <ul>
        </ul>
      </div>
    </nav>
    <main>
      <nav class="search-nav">
        <form class="search-form">
          <input class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Click or press 'S' to search...">
          </input>
        </form>
      </nav>
      <section class="search-results">
        <h1 class="search-results-header">
        </h1>
        <div class="search-results-content">
        </div>
      </section>
      <section class="main-content">
        <script>maybeShowSearchResults()</script>
        <div class="macro">
          <div class="section overview">
            <h1 class="section-header">
              <span>
                Macro
              </span>
              <a class="project-name" href="index.html">Subspace</a>
              <span class="namespace-dots">::</span>
              <a class="macro-name" href="#">sus_class_trivially_relocatable_if</a>
            </h1>
            <div class="overload-set">
              <div class="overload">
                <div class="macro-signature"><div class="src rightside"><a href="https://github.com/chromium/subspace/blob/main/sus/mem/relocate.h#L259">source</a></div><span class="macro-define">#define</span> <a class="macro-name" href="#">sus_class_trivially_relocatable_if</a>(unsafe_fn, is_trivially_reloc)</div>
              </div>
            </div>
            <div class="description long">
              <p>Mark a class as trivially relocatable based on a compile-time condition.</p>
<p>This macro is most useful in templates where the condition is based on the
template parameters.</p>
<p>Avoid marking the class with the <code>[[clang::trivial_abi]]</code> attribute, as when
the class is not trivially relocatable (the value is false), it can cause
memory safety bugs and Undefined Behaviour.</p>
<p>Use the <a href="sus-mem-TriviallyRelocatable.html"><code>TriviallyRelocatable</code></a> concept to
determine if a type is trivially relocatable, and to test with static_assert
that types are matching what you are expecting. This allows containers to
optimize their implementations when relocating the type in memory.</p>
<table>
<thead>
<tr>
<th>Macro</th>
<th>Style</th>
</tr>
</thead>
<tbody>
<tr>
<td><a href="macro.sus_class_trivially_relocatable.html"><code>sus_class_trivially_relocatable</code></a></td>
<td><strong>asserts</strong> all param types are trivially relocatable</td>
</tr>
<tr>
<td><a href="macro.sus_class_trivially_relocatable_if_types.html"><code>sus_class_trivially_relocatable_if_types</code></a></td>
<td>is <strong>conditionally</strong> trivially relocatable if all param types are</td>
</tr>
<tr>
<td><a href="macro.sus_class_trivially_relocatable_if.html"><code>sus_class_trivially_relocatable_if</code></a></td>
<td>is <strong>conditionally</strong> trivially relocatable if the condition is true</td>
</tr>
<tr>
<td><a href="macro.sus_class_trivially_relocatable_unchecked.html"><code>sus_class_trivially_relocatable_unchecked</code></a></td>
<td>is trivially relocatable without any condition or assertion</td>
</tr>
</tbody>
</table>
<h1><a name="example" href="#example">Example</a></h1>
<pre><code><span class="keyword">template</span> <span class="punct">&lt;</span><span class="keyword">class</span> T<span class="punct">&gt;</span>
<span class="keyword">struct</span> S <span class="punct">{</span>
  Thing<span class="punct">&lt;</span>i32<span class="punct">&gt;</span> thing<span class="punct">;</span>
  i32 more<span class="punct">;</span>

  sus_class_trivially_relocatable_if<span class="punct">(</span>
      unsafe_fn<span class="punct">,</span>
      SomeCondition<span class="punct">&lt;</span>Thing<span class="punct">&lt;</span>T<span class="punct">&gt;</span><span class="punct">&gt;</span>
      <span class="punct">&amp;</span><span class="punct">&amp;</span> sus::mem::TriviallyRelocatable<span class="punct">&lt;</span><span class="keyword">decltype</span><span class="punct">(</span>thing<span class="punct">)</span><span class="punct">&gt;</span>
      <span class="punct">&amp;</span><span class="punct">&amp;</span> sus::mem::TriviallyRelocatable<span class="punct">&lt;</span><span class="keyword">decltype</span><span class="punct">(</span>more<span class="punct">)</span><span class="punct">&gt;</span><span class="punct">)</span><span class="punct">;</span>
<span class="punct">}</span><span class="punct">;</span>
</code></pre>

            </div>
          </div>
        </div>
      </section>
    </main>
  </body>
</html>