libtalloc_stealing(3) [centos man page]

libtalloc_stealing(3)						      talloc						     libtalloc_stealing(3)

NAME

       libtalloc_stealing - Chapter 2: Stealing a context

Stealing a context
       Talloc has the ability to change the parent of a talloc context to another one. This operation is commonly referred to as stealing and it
       is one of the most important actions performed with talloc contexts.

       Stealing a context is necessary if we want the pointer to outlive the context it is created on. This has many possible use cases, for
       instance stealing a result of a database search to an in-memory cache context, changing the parent of a field of a generic structure to a
       more specific one or vice-versa. The most common scenario, at least in Samba, is to steal output data from a function-specific context to
       the output context given as an argument of that function.

       struct foo {
	   char *a1;
	   char *a2;
	   char *a3;
       };

       struct bar {
	   char *wurst;
	   struct foo *foo;
       };

       struct foo *foo = talloc_zero(ctx, struct foo);
       foo->a1 = talloc_strdup(foo, "a1");
       foo->a2 = talloc_strdup(foo, "a2");
       foo->a3 = talloc_strdup(foo, "a3");

       struct bar *bar = talloc_zero(NULL, struct bar);
       /* change parent of foo from ctx to bar */
       bar->foo = talloc_steal(bar, foo);

       /* or do the same but assign foo = NULL */
       bar->foo = talloc_move(bar, &foo);

       The talloc_move() function is similar to the talloc_steal() function but additionally sets the source pointer to NULL.

       In general, the source pointer itself is not changed (it only replaces the parent in the meta data). But the common usage is that the
       result is assigned to another variable, thus further accessing the pointer from the original variable should be avoided unless it is
       necessary. In this case talloc_move() is the preferred way of stealing a context. Additionally sets the source pointer to NULL,
       thus.protects the pointer from being accidentally freed and accessed using the old variable after its parent has been changed.

Version 2.0							  Tue Jun 17 2014					     libtalloc_stealing(3)

UNSET(3)								 1								  UNSET(3)

unset - Unset a given variable

SYNOPSIS

       void unset (mixed  $var, [mixed	$...])

DESCRIPTION

       unset(3) destroys the specified variables.

	The behavior of unset(3) inside of a function can vary depending on what type of variable you are attempting to destroy.

	If  a  globalized variable is unset(3) inside of a function, only the local variable is destroyed. The variable in the calling environment
       will retain the same value as before unset(3) was called.

       <?php
       function destroy_foo()
       {
	   global $foo;
	   unset($foo);
       }

       $foo = 'bar';
       destroy_foo();
       echo $foo;
       ?>

       The above example will output:

       bar

	To unset(3) a global variable inside of a function, then use the $GLOBALS array to do so:

       <?php
       function foo()
       {
	   unset($GLOBALS['bar']);
       }

       $bar = "something";
       foo();
       ?>

	If a variable that is PASSED BY REFERENCE is unset(3) inside of a function, only the local variable is	destroyed.  The  variable  in  the
       calling environment will retain the same value as before unset(3) was called.

       <?php
       function foo(&$bar)
       {
	   unset($bar);
	   $bar = "blah";
       }

       $bar = 'something';
       echo "$bar
";

       foo($bar);
       echo "$bar
";
       ?>

       The above example will output:

       something
       something

	If  a static variable is unset(3) inside of a function, unset(3) destroys the variable only in the context of the rest of a function. Fol-
       lowing calls will restore the previous value of a variable.

       <?php
       function foo()
       {
	   static $bar;
	   $bar++;
	   echo "Before unset: $bar, ";
	   unset($bar);
	   $bar = 23;
	   echo "after unset: $bar
";
       }

       foo();
       foo();
       foo();
       ?>

       The above example will output:

       Before unset: 1, after unset: 23
       Before unset: 2, after unset: 23
       Before unset: 3, after unset: 23

PARAMETERS

	      o $var
		- The variable to be unset.

	      o $...
		- Another variable ...

RETURN VALUES

	No value is returned.

EXAMPLES

       Example #1

	      unset(3) example

	      <?php
	      // destroy a single variable
	      unset($foo);

	      // destroy a single element of an array
	      unset($bar['quux']);

	      // destroy more than one variable
	      unset($foo1, $foo2, $foo3);
	      ?>

       Example #2

	      Using (unset) casting

	      (unset) casting is often confused with the unset(3) function.  (unset) casting serves only as a NULL-type cast, for completeness. It
	      does not alter the variable it's casting.

	      <?php
	      $name = 'Felipe';

	      var_dump((unset) $name);
	      var_dump($name);
	      ?>

	      The above example will output:

	      NULL
	      string(6) "Felipe"

NOTES

       Note

	      Because this is a language construct and not a function, it cannot be called using variable functions.

       Note

	       It is possible to unset even object properties visible in current context.

       Note

	       It is not possible to unset $this inside an object method since PHP 5.

       Note

	       When using unset(3) on inaccessible object properties, the __unset() overloading method will be called, if declared.

SEE ALSO

       isset(3), empty(3), __unset(), array_splice(3).

PHP Documentation Group 														  UNSET(3)