Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
native::Core(3)	      User Contributed Perl Documentation      native::Core(3)

       SVN::Core - Core	module of the subversion perl bindings

	   use SVN::Core; # does apr_initialize	and cleanup for	you

	   # create a root pool	and set	it as default pool for later use
	   my $pool = SVN::Pool->new_default;

	   sub something {
	       # create	a subpool of the current default pool
	       my $pool	= SVN::Pool->new_default_sub;
	       # some svn operations...

	       # $pool gets destroyed and the previous default pool
	       # is restored when $pool's lexical scope	ends

	   # svn_stream_t as native perl io handle
	   my $stream =	$txn->root->apply_text('trunk/filea', undef);
	   print $stream $text;
	   close $stream;

	   # native perl io handle as svn_stream_t
	   SVN::Repos::dump_fs($repos, \*STDOUT, \*STDERR,
			       0, $repos->fs->youngest_rev, 0);

       SVN::Core implements higher level functions of fundamental subversion

       SVN::Core::auth_open([auth provider array]);
	   Takes a reference to	an array of authentication providers and
	   returns an auth_baton.  If you use prompt providers you can not use
	   this	function, but need to use the auth_open_helper.

       SVN::Core::auth_open_helper([auth provider array]);
	   Prompt providers return two values instead of one.  The 2nd
	   parameter is	a reference to whatever	was passed into	them as	the
	   callback.  auth_open_helper splits up these arguments, passing the
	   provider objects into auth_open which gives it an auth_baton	and
	   putting the other ones in an	array.	The first return value of this
	   function is the auth_baton, the second is a reference to an array
	   containing the references to	the callbacks.

	   These callback arrays should	be stored in the object	the auth_baton
	   is attached to.

   svn_stream_t	- SVN::Stream
       You can use native perl io handles (including io	globs) as svn_stream_t
       in subversion functions.	Returned svn_stream_t are also translated into
       perl io handles,	so you could access them with regular print, read,

       Note that some functions	take a stream to read from or write to,	but do
       not close the stream while still	holding	the reference to the io
       handle.	In this	case the handle	won't be destroyed properly.  You
       should always set up the	correct	default	pool before calling such

   svn_pool_t -	SVN::Pool
       The perl	bindings significantly simplify	the usage of pools, while
       still being manually adjustable.

       For functions requiring a pool as the last argument (which are, almost
       all of the subversion functions), the pool argument is optional.	The
       default pool is used if it is omitted. When "SVN::Core" is loaded, it
       creates a new default pool, which is also available from

       For callback functions providing	a pool to your subroutine, you could
       also use	$pool->default to make it the default pool in the scope.


	   Create a new	pool. The pool is a root pool if $parent is not

	   Create a new	pool. The pool is a root pool if $parent is not
	   supplied.  Set the new pool as default pool.

	   Create a new	subpool	of the current default pool, and set the
	   resulting pool as new default pool.

	   Clear the pool.

	   Destroy the pool. If	the pool was the default pool, restore the
	   previous default pool. This is normally called automatically	when
	   the SVN::Pool object	is no longer used and destroyed	by the perl
	   garbage collector.

   svn_error_t - SVN::Error
       By default the perl bindings handle exceptions for you.	The default
       handler automatically croaks with an appropriate	error message.	This
       is likely sufficient for	simple scripts,	but more complex usage may
       demand handling of errors.

       You can override	the default exception handler by changing the
       $SVN::Error::handler variable.  This variable holds a reference to a
       perl sub	that should be called whenever an error	is returned by a svn
       function.  This sub will	be passed a svn_error_t	object.	  Its return
       value is	ignored.

       If you set the $SVN::Error::handler to undef then each call will	return
       an svn_error_t object as	its first return in the	case of	an error,
       followed	by the normal return values.  If there is no error then	a
       svn_error_t will	not be returned	and only the normal return values will
       be returned.  When using	this mode you should be	careful	only to	call
       functions in array context.  For	example: my ($ci) =
       $ctx->mkdir('http://svn/foo');  In this case $ci	will be	an svn_error_t
       object if an error occurs and a svn_client_commit_info object
       otherwise.  If you leave	the parenthesis	off around $ci (scalar
       context)	it will	be the commit_info object, which in the	case of	an
       error will be undef.

       If you plan on using explicit exception handling, understanding the
       exception handling system the C API uses	is helpful.  You can find
       information on it in the	HACKING	file and the API documentation.
       Looking at the implementation of	SVN::Error::croak_on_error and
       SVN::Error::expanded_message may	be helpful as well.

	   APR error value, possibly SVN_ custom error.

	   Details from	producer of error.

	   svn_error_t object of the error that's wrapped.

	   The pool holding this error and any child errors it wraps.

	   Source file where the error originated.

	   Source line where the error originated.

	   Returns the english description of the status code.

	   Returns the english description of the apr_err status code set on
	   the $svn_error_t.  This is short for:

       SVN::Error::create($apr_err, $child, $message);
	   Returns a new svn_error_t object with the error status specified in
	   $apr_err, the child as $child, and error message of $message.

       SVN::Error::quick_wrap($child, $new_msg); or
	   A quick n' easy way to create a wrappered exception with your own
	   message before throwing it up the stack.

	   $child is the svn_error_t object you	want to	wrap and $new_msg is
	   the new error string	you want to set.

       SVN::Error::compose($chain, $new_error);	or
	   Add new_err to the end of $chain's chain of errors.

	   The $new_err	chain will be copied into $chain's pool	and destroyed,
	   so $new_err itself becomes invalid after this function.

       SVN::Error::clear($svn_error_t);	or $svn_error_t->clear();
	   Free	the memory used	by $svn_error_t, as well as all	ancestors and
	   descendants of $svn_error_t.

	   You must call this on every svn_error_t object you get or you will
	   leak	memory.

       SVN::Error::expanded_message($svn_error_t) or
	   Returns the error message by	tracing	through	the svn_error_t	object
	   and its children and	concatenating the error	messages.  This	is how
	   the internal	exception handlers get their error messages.

	   Returns true	if value is of type svn_error.	Returns	false if value
	   is anything else or undefined.  This	is useful for seeing if	a call
	   has returned	an error.

	   Default error handler.  It takes an svn_error_t and extracts	the
	   error messages from it and croaks with those	messages.

	   It can be used in two ways.	The first is detailed above as setting
	   it as the automatic exception handler via setting

	   The second is if you	have $SVN::Error::handler set to undef as a
	   wrapper for calls you want to croak on when there is	an error, but
	   you don't want to write an explicit error handler. For example:

	   my $rev =

	   If there is no error	then croak_on_error will return	the arguments
	   passed to it	unchanged.

	   The same as croak_on_error except it	will give a more detailed
	   stack backtrace, including internal calls within the	implementation
	   of the perl bindings.  This is useful when you are doing
	   development work on the bindings themselves.

	   This	is useful for wrapping around calls which you wish to ignore
	   any potential error.	 It checks to see if the first parameter is an
	   error and if	it is it clears	it.  It	then returns all the other

	   'A'dd, 'D'elete, 'R'eplace, 'M'odify

	   Source path of copy,	or "undef" if there isn't any previous
	   revision history.

	   Source revision of copy, or $SVN::Core::INVALID_REVNUM if there is
	   no previous history.

       An object to represent a	path that changed for a	log entry.

	   'A'dd, 'D'elete, 'R'eplace, 'M'odify

	   Source path of copy,	or "undef" if there isn't any previous
	   revision history.

	   Source revision of copy, or $SVN::Core::INVALID_REVNUM if there is
	   no previous history.

	   The type of the node, a $SVN::Node enum; may	be

	   Is the text modified, a "SVN::Tristate" enum, may be

	   Are properties modified, a "SVN::Tristate" enum, may	be

   svn_node_kind_t - SVN::Node
       An enum of the following	constants:

       $SVN::Node::none, $SVN::Node::file, $SVN::Node::dir,

   svn_tristate_t - SVN::Tristate
       An enum of the following	constants:

       $SVN::Tristate::true, $SVN::Tristate::false, $SVN::Tristate::unknown

       Note that these true/false values have nothing to do with Perl's
       concept of truth. In fact, each constant	would evaluate to true in a
       boolean context.

   svn_depth_t - SVN::Depth
       An enum of the following	constants:

	   Depth undetermined or ignored.  In some contexts, this means	the
	   client should choose	an appropriate default depth.  The server will
	   generally treat it as $SVN::Depth::infinity.

	   Exclude (i.e., don't	descend	into) directory	D.

	   Note: In Subversion 1.5, $SVN::Depth::exclude is not	supported
	   anyhwere in the client-side (Wc/Client/etc) code; it	is only
	   supported as	an argument to set_path	functions in the Ra and	Repos
	   reporters.  (This will enable future	versions of Subversion to run
	   updates, etc, against 1.5 servers with proper $SVN::Depth::exclude
	   behavior, once we get a chance to implement client side support for

	   Just	the named directory D, no entries.

	   Updates will	not pull in any	files or subdirectories	not already

	   D + its files children, but not subdirs.

	   Updates will	pull in	any files not already present, but not

	   D + immediate children (D and its entries).

	   Updates will	pull in	any files or subdirectories not	already
	   present; those subdirectories' this_dir entries will	have depth-

	   D + all descendants (full recursion from D).

	   Updates will	pull in	any files or subdirectories not	already
	   present; those subdirectories' this_dir entries will	have depth-
	   infinity.  Equivalent to the	pre 1.5	default	update behavior.

       A revision, specified in	one of "SVN::Core::opt_revision_*" ways.

	   An enum denoting how	the revision $rev was specified.  One of
	   $SVN::Core::opt_revision_number, $SVN::Core::opt_revision_date,
	   $SVN::Core::opt_revision_previous, $SVN::Core::opt_revision_base,
	   $SVN::Core::opt_revision_working or $SVN::Core::opt_revision_head.

	   Extra data about the	revision. Only relevant	if "$rev->kind"	is
	   $SVN::Core::opt_revision_number (where it contains the revision
	   number) or $SVN::Core::opt_revision_date (where it contains a

       An object representing a	range of revisions.

	   The first revision in the range, a "_p_svn_opt_revision_t" object.

	   The last revision in	the range, a "_p_svn_opt_revision_t" object.

       Opaque object describing	a set of configuration options.

	   Node	kind.  A number	which matches one of these constants:
	   $SVN::Node::none, $SVN::Node::file, $SVN::Node::dir,

	   Length of file text,	or 0 for directories.

	   Does	the node have properties?

	   Last	revision in which this node changed.

	   Time	of created_rev (mod-time).

	   Author of created rev.

	   Just	committed revision.

	   Server-side date of the commit.

	   Author of the commit.

	   Error message from the post-commit hook, or undef.

	   Repository root, may	be "undef" if unknown.

	   The revision	of the commit.

	   A reference to a hash of requested revision properties, which may
	   be "undef" if it would contain no revprops.

	   Whether or not this message has children.

	   A reference to hash containing as keys every	path committed in
	   "$entry->revision()"; the values are	"_p_svn_log_changed_path2_t"

	   Whether "$entry->revision()"	should be interpreted as non-
	   inheritable in the same sense of "_p_svn_merge_range_t".

	   Whether "$entry->revision()"	is a merged revision resulting from a
	   reverse merge.



	   Indicates if	the credentials	may be saved (to disk).


	   Indicates if	the credentials	may be saved (to disk).

	   Indicates if	the credentials	may be saved (to disk).

	   Bit mask of the accepted failures.

	   Primary CN.

	   ASCII fingerprint.

	   ASCII date from which the certificate is valid.

	   ASCII date until which the certificate is valid.

	   DN of the certificate issuer.

	   Base-64 encoded DER certificate representation.

	   Full	paths to the certificate file.

	   Indicates if	the credentials	may be saved (to disk).

	   Certificate password.

	   Indicates if	the credentials	may be saved (to disk).

	   Certificate is not yet valid.

	   Certificate has expired.

	   Certificate's CN (hostname) does not	match the remote hostname.

	   Certificate authority is unknown (i.e. not trusted).

	   Other failure. This can happen if some unknown error	condition

       Objects of this class contain information about locks placed on files
       in a repository.	 It has	the following accessor methods:

	   The full path to the	file which is locked, starting with a forward
	   slash ("/").

	   A string containing the lock	token, which is	a unique URI.

	   The username	of whoever owns	the lock.

	   A comment associated	with the lock, or undef	if there isn't one.

	   True	if the comment was made	by a generic DAV client.

	   Time	at which the lock was created, as the number of	microseconds
	   since 00:00:00 JanuaryA 1, 1970 UTC.	 Divide	it by 1_000_000	to get
	   a Unix time_t value.

	   When	the lock will expire.  Has the value '0' if the	lock will
	   never expire.

       Chia-liang Kao <>

	   Licensed to the Apache Software Foundation (ASF) under one
	   or more contributor license agreements.  See	the NOTICE file
	   distributed with this work for additional information
	   regarding copyright ownership.  The ASF licenses this file
	   to you under	the Apache License, Version 2.0	(the
	   "License"); you may not use this file except	in compliance
	   with	the License.  You may obtain a copy of the License at

	   Unless required by applicable law or	agreed to in writing,
	   software distributed	under the License is distributed on an
	   KIND, either	express	or implied.  See the License for the
	   specific language governing permissions and limitations
	   under the License.

perl v5.32.1			  2018-02-24		       native::Core(3)


Want to link to this manual page? Use this URL:

home | help