# object

Forms the symbols available to all D programs. Includes Object, which is the root of the class object hierarchy. This module is implicitly imported.
License:
Boost License 1.0.
Authors:
Walter Bright, Sean Kelly

class Object;
  All D class objects inherit from Object.
  string toString();
    Convert Object to a human readable string.
  nothrow @trusted size_t toHash();
    Compute hash function for Object.
  int opCmp(Object o);
    Compare with another Object obj.
    Returns:

    this < obj | < 0
    this == obj | 0
    this > obj | > 0

  bool opEquals(Object o);
    Returns !=0 if this object does have the same contents as obj.
  static Object factory(string classname);
    Create instance of class specified by classname. The class must either have no constructors or have a default constructor.
    Returns:
    null if failed
bool opEquals(const Object lhs, const Object rhs);
  Returns true if lhs and rhs are equal.
struct Interface;
  Information about an interface. When an object is accessed via an interface, an Interface* appears as the first entry in its vtbl.
  TypeInfo_Class classinfo;
    .classinfo for this interface (not for containing class)
  ptrdiff_t offset;
    offset to Interface 'this' from Object 'this'
alias Classinfo = TypeInfo_Class;
  Runtime type information about a class. Can be retrieved for any class type or instance by using the .classinfo property. A pointer to this appears as the first entry in the class's vtbl[].
struct OffsetTypeInfo;
  Array of pairs giving the offset and type information for each member in an aggregate.
  size_t offset;
    Offset of member from start of object
  TypeInfo ti;
    TypeInfo for this member
class TypeInfo;
  Runtime type information about a type. Can be retrieved for any type using a TypeidExpression.
  const nothrow @trusted size_t getHash(in void* p);
    Returns a hash of the instance of a type.
  const bool equals(in void* p1, in void* p2);
    Compares two instances for equality.
  const int compare(in void* p1, in void* p2);
    Compares two instances for <, ==, or >.
  const pure nothrow @property @safe size_t tsize();
    Returns size of the type.
  const void swap(void* p1, void* p2);
    Swaps two instances of the type.
  inout pure nothrow @property inout(TypeInfo) next();
    Get TypeInfo for 'next' type, as defined by what kind of type this is, null if none.
  const pure nothrow @safe const(void)[] init();
    Return default initializer. If the type should be initialized to all zeros, an array with a null ptr and a length equal to the type size will be returned.
  const pure nothrow @property @safe uint flags();
    Get flags for type: 1 means GC should scan for pointers
  const const(OffsetTypeInfo)[] offTi();
    Get type information on the contents of the type; null if not available
  const void destroy(void* p);
    Run the destructor on the object and all its sub-objects
  const void postblit(void* p);
    Run the postblit on the object and all its sub-objects
  const pure nothrow @property @safe size_t talign();
    Return alignment of type
  const pure nothrow @property @safe immutable(void)* rtInfo();
    Return info used by the garbage collector to do precise collection.
class TypeInfo_Class: object.TypeInfo;
  Runtime type information about a class. Can be retrieved from an object instance by using the .classinfo property.
  byte[] init;
    class static initializer (init.length gives size in bytes of class)
  string name;
    class name
  void*[] vtbl;
    virtual function pointer table
  Interface[] interfaces;
    interfaces this class implements
  TypeInfo_Class base;
    base class
  static const(TypeInfo_Class) find(in char[] classname);
    Search all modules for TypeInfo_Class corresponding to classname.
    Returns:
    null if not found
  const Object create();
    Create instance of Object represented by 'this'.
class Throwable;
  The base class of all thrown objects.
  All thrown objects must inherit from Throwable. Class , which derives from this class, represents the category of thrown objects that are safe to catch and handle. In principle, one should not catch Throwable objects that are not derived from , as they represent unrecoverable runtime errors. Certain runtime guarantees may fail to hold when these errors are thrown, making it unsafe to continue execution after catching them.
  string msg;
    A message describing the error.
  string file;
  size_t line;
    The file name and line number of the D source code corresponding with where the error was thrown from.
  TraceInfo info;
    The stack trace of where the error happened. This is an opaque object that can either be converted to , or iterated over with to extract the items in the stack trace (as strings).
  Throwable next;
    A reference to the next error in the list. This is used when a new is thrown from inside a block. The originally caught will be chained to the new via this field.
void rt_setTraceHandler(TraceHandler h);
  Overrides the default trace hander with a user-supplied version.
  Params:

  TraceHandler h | The new trace handler. Set to null to use the default handler.

TraceHandler rt_getTraceHandler();
  Return the current trace handler
Throwable.TraceInfo _d_traceContext(void* ptr = null);
  This function will be called when an exception is constructed. The user-supplied trace handler will be called if one has been supplied, otherwise no trace will be generated.
  Params:

  void* ptr | A pointer to the location from which to generate the trace, or null if the trace should be generated from within the trace handler itself.

  Returns:
  An object describing the current calling context or null if no handler is supplied.
class Exception: object.Throwable;
  The base class of all errors that are safe to catch and handle.
  In principle, only thrown objects derived from this class are safe to catch inside a block. Thrown objects not derived from Exception represent runtime errors that should not be caught, as certain runtime guarantees may not hold, making it unsafe to continue program execution.
  this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null);
    Creates a new instance of Exception. The next parameter is used internally and should be always be when passed by user code. This constructor does not automatically throw the newly-created Exception; the statement should be used for that purpose.
alias IMonitor = Object.Monitor;
void destroy(T)(T obj);
  Destroys the given object and puts it in an invalid state. It's used to destroy an object so that any cleanup which its destructor or finalizer does is done and so that it no longer references any other objects. It does not initiate a GC cycle or free any GC memory.
pure nothrow size_t capacity(T)(T[] arr);
  (Property) Get the current capacity of a slice. The capacity is the size that the slice can grow to before the underlying array must be reallocated or extended.
  If an append must reallocate a slice with no possibility of extension, then 0 is returned. This happens when the slice references a static array, or if another slice references elements past the end of the current slice.
  Note:
  The capacity of a slice may be impacted by operations on other slices.
  Examples:

      //Static array slice: no capacity
      int[4] sarray = [1, 2, 3, 4];
      int[]  slice  = sarray[];
      assert(sarray.capacity == 0);
      //Appending to slice will reallocate to a new array
      slice ~= 5;
      assert(slice.capacity >= 5);

      //Dynamic array slices
      int[] a = [1, 2, 3, 4];
      int[] b = a[1 .. $];
      int[] c = a[1 .. $ - 1];
      assert(a.capacity != 0);
      assert(a.capacity == b.capacity + 1); //both a and b share the same tail
      assert(c.capacity == 0);              //an append to c must relocate c.

pure nothrow size_t reserve(T)(ref T[] arr, size_t newcapacity);
  Reserves capacity for a slice. The capacity is the size that the slice can grow to before the underlying array must be reallocated or extended.
  The return value is the new capacity of the array (which may be larger than the requested capacity).
  Examples:

      //Static array slice: no capacity. Reserve relocates.
      int[4] sarray = [1, 2, 3, 4];
      int[]  slice  = sarray[];
      auto u = slice.reserve(8);
      assert(u >= 8);
      assert(sarray.ptr !is slice.ptr);
      assert(slice.capacity == u);

      //Dynamic array slices
      int[] a = [1, 2, 3, 4];
      a.reserve(8); //prepare a for appending 4 more items
      auto p = a.ptr;
      u = a.capacity;
      a ~= [5, 6, 7, 8];
      assert(p == a.ptr);      //a should not have been reallocated
      assert(u == a.capacity); //a should not have been extended

void assumeSafeAppend(T)(T[] arr);
  Assume that it is safe to append to this array. Appends made to this array after calling this function may append in place, even if the array was a slice of a larger array to begin with.
  Use this only when you are sure no elements are in use beyond the array in the memory block. If there are, those elements could be overwritten by appending to this array.
  Calling this function, and then using references to data located after the given array results in undefined behavior.
  Examples:

      int[] a = [1, 2, 3, 4];
      int[] b = a[1 .. $ - 1];
      assert(a.capacity >= 4);
      assert(b.capacity == 0);
      b.assumeSafeAppend();
      assert(b.capacity >= 3);

bool _ArrayEq(T1, T2)(T1[] a1, T2[] a2);
  Helper function used to see if two containers of different types have the same contents in the same sequence.
template RTInfo(T)
  Create RTInfo for type T

Page generated by Ddoc. Copyright Digital Mars 2000 - 2011.