text:
module CommunityExtensions::Shapes

  # Create a mix-in module that can be used to extend Geom::PolygonMesh
  # instances. These methods used to previously modify the base classes
  # themselves.
  module PolygonMeshHelper

    # Revolve edges defined by an array of points about an axis
    # pts is an Array of points
    # axis is an Array with a point and a vector
    # numsegments is the number of segments in the rotation direction
    def add_revolved_points(pts, axis, numsegments)

      # Make sure that there are enough points
      numpts = pts.length
      if( numpts < 2 )
        raise ArgumentError, "At least two points required", caller
      end

      #TODO: Determine if the points are all in the same plane as the axis
      planar = true

      # Create a transformation that will revolve the points
      angle = Math::PI * 2
      da = angle / numsegments
      t = Geom::Transformation.rotation(axis[0], axis[1], da)

      # Add the points to the mesh
      index_array = []
      for pt in pts do
        if( pt.on_line?(axis) )
          index_array.push( [self.add_point(pt)] )
        else
          indices = []
          for i in 0...numsegments do
            indices.push( self.add_point(pt) )
            #puts "add #{pt} at #{indices.last}"
            pt.transform!(t)
          end
          index_array.push indices
        end
      end

      # Now create polygons using the point indices
      i1 = index_array[0]
      for i in 1...numpts do
        i2 = index_array[i]
        n1 = i1.length
        n2 = i2.length
        nest if( n1 < numsegments && n2 < numsegments )

        for j in 0...numsegments do
          jp1 = (j + 1) % numsegments
          if( n1 < numsegments )
            self.add_polygon i1[0], i2[jp1], i2[j]
            #puts "add_poly #{i1[0]}, #{i2[jp1]}, #{i2[j]}"
          elsif( n2 < numsegments )
            self.add_polygon i1[j], i1[jp1], i2[0]
            #puts "add_poly #{i1[j]}, #{i1[jp1]}, #{i2[0]}"
          else
            if( planar )
              self.add_polygon i1[j], i1[jp1], i2[jp1], i2[j]
            else
              # Try adding two triangles instead
              self.add_polygon i1[j], i1[jp1], i2[jp1]
              self.add_polygon i1[j], i2[jp1], i2[j]
            end
            #puts "add_poly #{i1[j]}, #{i1[jp1]}, #{i2[jp1]}, #{i2[j]}"
          end
        end

        i1 = i2
      end

    end

    # Extrude points along an axis with a rotation
    def add_extruded_points(pts, center, dir, angle, numsegments)

      # Make sure that there are enough points
      numpts = pts.length
      if( numpts < 2 )
        raise ArgumentError, "At least two points required", caller
      end

      # compute the transformation
      vec = Geom::Vector3d.new dir
      distance = vec.length
      dz = distance / numsegments
      da = angle / numsegments
      vec.length = dz
      t = Geom::Transformation.translation vec
      r = Geom::Transformation.rotation center, dir, da
      tform = t * r

      # Add the points to the mesh
      index_array = []
      for i in 0...numsegments do
        indices = []
        for pt in pts do
          indices.push( self.add_point(pt) )
          pt.transform!(tform)
        end
        index_array.push indices
      end

      # Now create polygons using the point indices
      i1 = index_array[0]
      for i in 1...numsegments do
        i2 = index_array[i]

        for j in 0...numpts do
          k = (j+1) % numpts
          self.add_polygon -i1[j], i2[k], -i1[k]
          self.add_polygon i1[j], -i2[j], -i2[k]
        end

        i1 = i2
      end

    end

  end # module PolygonMeshHelper
end # module CommunityExtensions::Shapes


text:
<?php
class LdapObjectsController extends AppController {
    var $name = 'LdapObjects';
    var $components = array('RequestHandler');
    var $helpers = array('Form','Html');

    function view( $id ){
        if(!empty($id)){
            // $this->loadModel('Ldapobject');
            $filter = $this->LdapObject->primaryKey."=".$id;
            $ldapObjects = $this->LdapObject->find('first', array( 'conditions'=>$filter));

            $ldapError = $this->LdapObject->getLdapError();

            $this->set(compact('ldapObjects'));
            $this->set('ldapError');

        }
        // $this->layout = 'ldapobjects';

    }
}
?>

redpajama_set_name: RedPajamaGithub


text:
require "ordered_find/version"
require "active_record"

module ActiveRecord
  class Relation
    def ordered_find(*args)
      ids = args.flatten
      find(ids.uniq).index_by(&:id).values_at(*ids)
    end

    def ordered_find_by_id(*args)
      ids = args.flatten
      where(id: ids.uniq).index_by(&:id).values_at(*ids)
    end
  end

  class Base
    class << self
      delegate :ordered_find, to: :all
      delegate :ordered_find_by_id, to: :all
    end
  end
end


text:
namespace Merchello.Core.Persistence.Migrations.Upgrades.TargetVersionTwoFiveZero
{
    using Merchello.Core.Configuration;
    using Merchello.Core.Models.Rdbms;

    using Umbraco.Core;
    using Umbraco.Core.Logging;
    using Umbraco.Core.Persistence;
    using Umbraco.Core.Persistence.Migrations;

    /// <summary>
    /// Adds the digital media table.
    /// </summary>
    [Migration("2.5.0", 2, MerchelloConfiguration.MerchelloMigrationName)]
    public class AddDigitalMediaTable : MerchelloMigrationBase, IMerchelloMigration
    {
        /// <summary>
        /// The _schema helper.
        /// </summary>
        private readonly DatabaseSchemaHelper _schemaHelper;

        /// <summary>
        /// Initializes a new instance of the <see cref="AddDigitalMediaTable"/> class.
        /// </summary>
        public AddDigitalMediaTable()
        {
            var dbContext = ApplicationContext.Current.DatabaseContext;
            _schemaHelper = new DatabaseSchemaHelper(dbContext.Database, LoggerResolver.Current.Logger, dbContext.SqlSyntax);
        }

        /// <summary>
        /// Adds the indexes to the merchDigitalMedia table.
        /// </summary>
        public override void Up()
        {
            if (!_schemaHelper.TableExist("merchDigitalMedia"))
            {
                _schemaHelper.CreateTable(false, typeof(DigitalMediaDto));
            }
        }

        /// <summary>
        /// Downgrades the database.
        /// </summary>
        public override void Down()
        {
            throw new DataLossException("Cannot downgrade from a version 2.5.0 database to a prior version, the database schema has already been modified");
        }
    }
}


text:
from webob import Request, Response
from nova.openstack.common import log as logging
from eventlet.green.httplib import HTTPConnection, HTTPSConnection

CIMI_CONTENT_TYPES = ['application/json', 'application/xml']
LOG = logging.getLogger(__name__)

def get_err_response(code):
    """
    Given an HTTP response code, create a properly formatted error response

    :param code: error code
    :returns: webob.response object
    """

    error_table = {
        'AccessDenied':
            (403, 'Access denied'),
        'BadRequest':
            (400, 'Bad request'),
        'MalformedBody':
            (400, 'Request body can not be parsed, malformed request body'),
        'NotFound':
            (404, 'Resource was not found'),
        'NotImplemented':
            (501, 'Not implemented'),
        'TestRequest':
            (200, 'Test request'),
        'Conflict':
            (409, 'The requested name already exists as a different type')}

    resp = Response()
    resp.status = error_table[code][0]
    resp.body = error_table[code][1]
    return resp

def concat(*args):
    return ''.join(args)

def best_match(content_type):
    """
    Use webob request accept member to determine what is the best match
    for a given content type. This can be used for determining both request
    and response content type
    """

    try:
        req = Request.blank('/')
        req.accept = content_type.lower()
        return req.accept.best_match(CIMI_CONTENT_TYPES) or 'application/json'
    except:
        return 'application/json'

def get_href(data, member):
    if data:
        if data.get(member):
            return data.get(member).get('href')

    return None

def get_last_part(path):
    if path:
        parts = path.rstrip('/ ').split('/')
        return parts[-1]
    return ''

def sub_path(path, map):
    for k, v in map.items():
        path = path.replace(k, v, 1)
    return path

def match_up(data_to, data_from, key_to, key_from):
    def get_member(data, key_path, get_parent):
        value = None
        mem_key = None
        if key_path:
            keys = key_path.strip('/').split('/')
            key_lens = len(keys)
            if get_parent:
                key_lens -= 1
                mem_key = keys[-1]
            value = data
            for idx in range(key_lens):
                if value:
                    value = value.get(keys[idx])
                else:
                    break
        return value, mem_key
    data, key = get_member(data_to, key_to, True)
    if key:
        data[key] = get_member(data_from, key_from, False)[0]

def match_up_extra(data_to, data_from, keys_to_exclude):

    for key in data_from:
        if key in keys_to_exclude:
            pass
        else:
            data_to[key] = data_from.get(key)

def has_extra(data_from, keys_to_exclude):
    for key in data_from:
        exclude_keys = keys_to_exclude.keys()
        if key in exclude_keys:
            value = keys_to_exclude.get(key)
            if value:
                if has_extra(data_from.get(key), value):
                    return True
        else:
            return True
    return False

def remove_member(data, member):
    if isinstance(data, dict):
        if member in data.keys():
            data.pop(member)
        for key in data:
            remove_member(data.get(key), member)
    elif isinstance(data, list):
        for one in data:
            remove_member(one, member)

MACHINE_STATE_MAP = {'ACTIVE': 'STARTED', 'REBOOT': 'STARTING',
    'HARD_REBOOT': 'STARTING', 'PASSWORD': 'UNKNOWN', 'REBUILD': 'STARTING',
    'MIGRATING': 'STARTING', 'RESIZE': 'STARTING', 'BUILD': 'STARTING',
    'SHUTOFF': 'STOPPED', 'VERIFY_RESIZE': 'STARTING',
    'REVERT_RESIZE': 'STARTING', 'PAUSED': 'PAUSED', 'SUSPENDED': 'SUSPENDED',
    'RESCUE': 'STARTING', 'ERROR': 'ERROR', 'DELETED': 'DELETING'}

def map_machine_state(value):
    return MACHINE_STATE_MAP.get(value, 'UNKNOWN')

VOLUME_STATE_MAP = {'creating': 'CREATING',
                    'available': 'AVAILABLE',
                    'deleting': 'DELETING',
                    'attaching': 'ATTACHING',
                    'detaching': 'DETACHING',
                    'in-use': 'INUSE',
                    'error': 'ERROR',
                    'error_deleting': 'ERROR'}

def map_volume_state(value):
    return VOLUME_STATE_MAP.get(value, 'UNKNOWN')

IMAGE_STATE_MAP = {'queued': 'CREATING', 'saving': 'CREATING',
                   'active': 'AVAILABLE', 'killed': 'DELETED',
                   'deleted': 'DELETED', 'pending_delete': 'DELETING'}

def map_image_state(value):
    return IMAGE_STATE_MAP.get(value.lower(), 'UNKNOWN')

def access_resource(env, method, path, get_body=False,
                    query_string=None, body=None):
    """
    Use this method to send a http request
    If the resource exists, then it should return True with headers.
    If the resource does not exist, then it should return False with None
    headers
    If the get_body is set to True, the response body will also be returned
    """

    # Create a new Request
    req = Request(env)
    if req.scheme.lower() == 'https':
        connection = HTTPSConnection
        ssl = True
    else:
        connection = HTTPConnection
        ssl = False

    headers = {}
    headers['Accept'] = 'application/json'
    for header, value in req.headers.items():
        headers[header] = value

    method = 'GET' if not method else method
    path = req.path if not path else path

    conn = connection(req.server_name, req.server_port)

    conn.request(method, path, body, headers)
    res = conn.getresponse()

    if res.status == 404 or res.status == 413:
        conn.close()
        return False, {}, None, res.status
    elif (res.status == 200 or res.status == 204 or
          res.status == 201):
        values = {}
        header_list = res.getheaders()
        for header in header_list:
            values[header[0]] = header[1]
        if get_body:
            length = res.getheader('content-length')
            if length:
                body = res.read(int(length))
            else:
                body = res.read()
        else:
            body = ""
        conn.close()
        return True, values, body, res.status
    else:
        values = {}
        header_list = res.getheaders()
        for header in header_list:
            values[header[0]] = header[1]
        conn.close()
        return True, values, None, res.status


text:
struct Color;

namespace ride::apigl
{

struct Texture;

constexpr int MAX_GLYPHSET = 256;
constexpr int NUM_CHARS = 256;

struct LoadedFontData;

// "mirror" of stbtt_bakedchar
struct Glyph
{
    int x0; int y0;
    int x1; int y1;

    int xoff; int yoff;
    int xadvance;

    void make_invisible();
};

struct GlyphSet
{
    bool loaded = false;
    std::shared_ptr<Texture> texture;
    std::array<Glyph, NUM_CHARS> glyphs;

    Glyph* get_glyph(unsigned int c);
    bool load_single_glyphset_or_fail(LoadedFontData* font, int idx, int width, int height);
    void load_glyphset(LoadedFontData* font, int idx);
};

struct FontImpl
{
    std::unique_ptr<LoadedFontData> data;
    GlyphSet sets[MAX_GLYPHSET];

    FontImpl();
    ~FontImpl();

    GlyphSet* get_glyphset(unsigned int codepoint);
    Glyph* get_glyph(unsigned int codepoint);
    void mark_as_unloaded();

    Px get_data_height() const;
};

struct Font : ::Font
{
    Font();
    ~Font();

    std::unique_ptr<FontImpl> m;

    bool load_font(const std::string& filename, Px size) override;

    bool load_font(const embedded_binary& data, Px size);
    bool impl_load_font(std::unique_ptr<FontImpl> f, const unsigned char* data, Px size);

    void set_size(Px new_size);

    void set_tab_width(Px n);
    Px get_tab_width();

    Px get_width(const std::string& text) override;
    Px get_height() const override;
};

}


text:
/*
ouvrir invite de ligne de commande =>
  mysql -u root [ -p ] (puis saisir votre mot de passe d'utilisateur mysql)
                   ('' sur windows par defaut, 'root' sous mac)
quitter invite de ligne de commande =>
  quit;
    si bloqué... tenter : contrôle + C
*/

/*
Ressources =>
  la doc officielle :
    https://dev.mysql.com/doc/refman/5.7/en/ (ET son moteur de recherce)
  good cookbook :
    https://www.tutorialspoint.com/mysql
*/
-- DEBOGUER (avec moteur innoDB)
SHOW ENGINE INNODB STATUS;

/*
  innoDB ou MyISAM ?
  http://sql.sh/1548-mysql-innodb-myisam
*/

-- lister les bases de données du système
SHOW DATABASES;
-- créer une nouvelle base de données
CREATE DATABASE nom_base;
-- utiliser nom_base comme base courante
USE nom_base;
-- lister les tables de la base courante
SHOW TABLES;
-- lister les index et clés d'une table
SHOW INDEXES IN nom_table;
-- lister les colones d'une table + types et clés (PK / FK)
SHOW COLUMNS FROM nom_table;
-- renommer table
RENAME TABLE nom_table TO nom_table_new;

-- SUPPRESSION
-- D'UNE BASE DE DONNEES COMPLETE !
DROP DATABASE nom_base;
-- D'UNE TABLE DE LA BASE DE DONNÉES COURANTE !
DROP TABLE nom_table;
-- exemple :
-- DROP TABLE utilisateurs;
-- DROP TABLE factures;
-- créer table
CREATE TABLE users (
  id INT(6) UNSIGNED NOT NULL AUTO_INCREMENT,
  name VARCHAR(30) NOT NULL,
  lastname VARCHAR(30) NOT NULL,
  email VARCHAR(50),
  PRIMARY KEY(id)
);

CREATE TABLE bills (
  id INT(6) UNSIGNED NOT NULL AUTO_INCREMENT,
  id_user INT(6) UNSIGNED NOT NULL,
  total DECIMAL(13,2) NOT NULL,
  created_at DATETIME,
  PRIMARY KEY (id),
  FOREIGN KEY (id_user) REFERENCES users(id)
);

CREATE TABLE genres (
  id INT(6) UNSIGNED NOT NULL AUTO_INCREMENT,
  label VARCHAR(30) NOT NULL,
  PRIMARY KEY (id)
);

CREATE TABLE persos (
  id INT(6) UNSIGNED NOT NULL AUTO_INCREMENT,
  id_genre INT(6) UNSIGNED,
  nom VARCHAR(30) NOT NULL,
  PRIMARY KEY (id),
  FOREIGN KEY (id_genre)
    REFERENCES genres(id)
    ON UPDATE CASCADE ON DELETE SET NULL
);

-- CRUD
-- CREATE
INSERT INTO users (nom, prenom) VALUES ('ada', 'lovelace');
INSERT INTO users (nom, prenom, email) VALUES ('jimmy', 'page', 'jimmy@gmail.com');
INSERT INTO users (nom, prenom, email) VALUES ('nom', 'bidon', null);
INSERT INTO users (nom, prenom, email) VALUES ('brendan', 'eich', 'js@js.js');
INSERT INTO users (nom, prenom, email) VALUES ('douglas', 'crockford', 'jstoo@js.js');
INSERT INTO users (nom, prenom, email) VALUES ('larry', 'page', 'owner@google.com');
INSERT INTO users (nom, prenom, email) VALUES ('linus', 'torvalds', 'iluv@linux.org');
INSERT INTO users (nom, prenom, email) VALUES ('edgar', 'poe', 'poem@crow.net');
INSERT INTO users (nom, prenom, email) VALUES ('bob', 'marley', 'rasta@jah.jm');
INSERT INTO bills (id_client, date_creation, total) VALUES (2, CURDATE(), 1000);
INSERT INTO bills (id_client, date_creation, total) VALUES (2, CURDATE(), 9.99);
INSERT INTO bills (id_client, date_creation, total) VALUES (3, CURDATE(), 23.99);
INSERT INTO bills (id_client, date_creation, total) VALUES (1, CURDATE(), 300.01);
INSERT INTO bills (id_client, date_creation, total) VALUES (5, CURDATE(), 13.99);
INSERT INTO bills (id_client, date_creation, total) VALUES (4, CURDATE(), 13.99);
-- READ
SELECT * FROM users;
SELECT * FROM users WHERE id = 1;
SELECT nom FROM users WHERE id < 10;
SELECT nom, email FROM users WHERE nom = 'page';
-- LIKE CLAUSE
-- lister les lignes dont colonne_table commencent par 'a'
SELECT * FROM nom_table WHERE colonne_table LIKE 'a%';
-- lister les lignes dont colonne_table finissent par 'a'
SELECT * FROM nom_table WHERE colonne_table LIKE '%a';
-- lister les lignes dont colonne_table contiennent 'ai'
SELECT * FROM nom_table WHERE colonne_table LIKE '%ai%';
-- UPDATE
UPDATE users SET email = 'computermum@binary.com' WHERE nom = 'ada';
UPDATE users SET email = 'guitarhero@email.com' WHERE id = 2;
UPDATE users SET
              nom = 'george',
              prenom = 'abitbol',
              email = 'guitarhero@email.com'
                WHERE id = 3;
-- DELETE
DELETE FROM users WHERE id = 1;
DELETE FROM users WHERE email = 'computermum@binary.com';
DELETE FROM users WHERE id;

-- ALTER TABLE
ALTER TABLE users ADD age TINYINT;


text:
<?php

$response = array();

require_once __DIR__ . '/db_connect.php';

$db = new DB_CONNECT();

if (isset($_GET['id'])) {
    $id = $_GET['id'];

    $result = mysql_query("SELECT *FROM autobusy WHERE id = $id");

    if (!empty($result)) {
        if (mysql_num_rows($result) > 0) {

            $result = mysql_fetch_array($result);

            $bus = array();
            $bus["id"] = $result["id"];
            $bus["linia"] = $result["linia"];
            $bus["kurs"] = $result["kurs"];
            $bus["lat"] = $result["lat"];
            $bus["lng"] = $result["lng"];
			$bus["speed"] = $result["speed"];
            $bus["updated_at"] = $result["updated_at"];

            $response["success"] = 1;

            $response["bus"] = array();

            array_push($response["bus"], $bus);

            echo json_encode($response);
        } else {
            $response["success"] = 0;
            $response["message"] = "No bus found";

            echo json_encode($response);
        }
    } else {
        $response["success"] = 0;
        $response["message"] = "No bus found";

        echo json_encode($response);
    }
} else {
    $response["success"] = 0;
    $response["message"] = "Required field(s) is missing";

    echo json_encode($response);
}
?>


text:
using Blogifier.Core.Common;
using Blogifier.Core.Data.Domain;
using Blogifier.Core.Data.Interfaces;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;

namespace Blogifier.Core.Data.Repositories
{
    public class CategoryRepository : Repository<Category>, ICategoryRepository
    {
        BlogifierDbContext _db;

        public CategoryRepository(BlogifierDbContext db) : base(db)
        {
            _db = db;
        }

        public IEnumerable<Category> Find(Expression<Func<Category, bool>> predicate, Pager pager)
        {
            if(pager == null)
            {
                return _db.Categories.AsNoTracking()
                    .Include(c => c.PostCategories)
                    .Where(predicate)
                    .OrderBy(c => c.Title);
            }

            var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;

            var categories = _db.Categories.AsNoTracking()
                .Include(c => c.PostCategories)
                .Where(predicate)
                .OrderBy(c => c.Title)
                .ToList();

            pager.Configure(categories.Count());

            return categories.Skip(skip).Take(pager.ItemsPerPage);
        }

        public IEnumerable<SelectListItem> PostCategories(int postId)
        {
            var items = new List<SelectListItem>();
            var postCategories = _db.PostCategories.Include(pc => pc.Category).Where(c => c.BlogPostId == postId);
            foreach (var item in postCategories)
            {
                var newItem = new SelectListItem { Value = item.Id.ToString(), Text = item.Category.Title };
                if (!items.Contains(newItem))
                {
                    items.Add(newItem);
                }
            }
            return items.OrderBy(c => c.Text);
        }

        public IEnumerable<SelectListItem> CategoryList(Expression<Func<Category, bool>> predicate)
        {
            return _db.Categories.Where(predicate).OrderBy(c => c.Title)
                .Select(c => new SelectListItem { Text = c.Title, Value = c.Id.ToString() }).ToList();
        }

        public async Task<Category> SingleIncluded(Expression<Func<Category, bool>> predicate)
        {
            return await _db.Categories.AsNoTracking()
                .Include(c => c.PostCategories)
                .FirstOrDefaultAsync(predicate);
        }

        public bool AddCategoryToPost(int postId, int categoryId)
        {
            try
            {
                var existing = _db.PostCategories.Where(
                    pc => pc.BlogPostId == postId &&
                    pc.CategoryId == categoryId).SingleOrDefault();

                if (existing == null)
                {
                    _db.PostCategories.Add(new PostCategory
                    {
                        BlogPostId = postId,
                        CategoryId = categoryId,
                        LastUpdated = SystemClock.Now()
                    });
                    _db.SaveChanges();
                }
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        public bool RemoveCategoryFromPost(int postId, int categoryId)
        {
            try
            {
                var existing = _db.PostCategories.Where(
                    pc => pc.BlogPostId == postId &&
                    pc.CategoryId == categoryId).SingleOrDefault();
                _db.PostCategories.Remove(existing);
                return true;
            }
            catch
            {
                return false;
            }
        }
    }
}


text:
@implementation MKARMDataModel

//|++++++++++++++++++++++++++++++++++++|//
- (instancetype)initWithDataSource:(MKDataModel*)dataSource endianness:(MKDataEndianness)endianness;
{
    self = [self initWithDataSource:dataSource];

    _endianness = endianness;

    return self;
}

//|++++++++++++++++++++++++++++++++++++|//
- (MKDataEndianness)endianness
{
    if (_endianness != MKDataEndiannessUnknown)
        return _endianness;
    else
        // Defer to the data source.
        return [super endianness];
}

//|++++++++++++++++++++++++++++++++++++|//
// TODO: Does ARM always use the full pointer width for the address?
- (uint64_t)pointerMask
{ return 0xFFFFFFFF; }

// Defer to data source for everything else.

@end

//----------------------------------------------------------------------------//
@implementation MKAARCH64DataModel

//|++++++++++++++++++++++++++++++++++++|//
- (instancetype)initWithDataSource:(MKDataModel*)dataSource endianness:(MKDataEndianness)endianness;
{
    self = [self initWithDataSource:dataSource];

    _endianness = endianness;

    return self;
}

//|++++++++++++++++++++++++++++++++++++|//
- (MKDataEndianness)endianness
{
    if (_endianness != MKDataEndiannessUnknown)
        return _endianness;
    else
        // Defer to the data source.
        return [super endianness];
}

//|++++++++++++++++++++++++++++++++++++|//
// TODO: Unclear if the AARCH64 architecture enforces a maximum VM address size.  The linux & darwin ABIs do, but they are not this class's concern.
- (uint64_t)pointerMask
{ return 0xFFFFFFFFFFFFFFFF; }

// Defer to data source for everything else.

@end