git.gag.com Git - debian/amanda/blob - perl/Amanda/Device.pm

   1 # This file was automatically generated by SWIG (http://www.swig.org).
   2 # Version 1.3.33
   3 #
   4 # Don't modify this file, modify the SWIG interface instead.
   5
   6 package Amanda::Device;
   7 require Exporter;
   8 require DynaLoader;
   9 @ISA = qw(Exporter DynaLoader);
  10 require Amanda::Types;
  11 package Amanda::Devicec;
  12 bootstrap Amanda::Device;
  13 package Amanda::Device;
  14 @EXPORT = qw( );
  15
  16 # ---------- BASE METHODS -------------
  17
  18 package Amanda::Device;
  19
  20 sub TIEHASH {
  21     my ($classname,$obj) = @_;
  22     return bless $obj, $classname;
  23 }
  24
  25 sub CLEAR { }
  26
  27 sub FIRSTKEY { }
  28
  29 sub NEXTKEY { }
  30
  31 sub FETCH {
  32     my ($self,$field) = @_;
  33     my $member_func = "swig_${field}_get";
  34     $self->$member_func();
  35 }
  36
  37 sub STORE {
  38     my ($self,$field,$newval) = @_;
  39     my $member_func = "swig_${field}_set";
  40     $self->$member_func($newval);
  41 }
  42
  43 sub this {
  44     my $ptr = shift;
  45     return tied(%$ptr);
  46 }
  47
  48
  49 # ------- FUNCTION WRAPPERS --------
  50
  51 package Amanda::Device;
  52
  53 *IS_WRITABLE_ACCESS_MODE = *Amanda::Devicec::IS_WRITABLE_ACCESS_MODE;
  54 *feature_support_flags_is_valid = *Amanda::Devicec::feature_support_flags_is_valid;
  55
  56 ############# Class : Amanda::Device::Device ##############
  57
  58 package Amanda::Device::Device;
  59 use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
  60 @ISA = qw( Amanda::Device );
  61 %OWNER = ();
  62 %ITERATORS = ();
  63 *swig_file_get = *Amanda::Devicec::Device_file_get;
  64 *swig_file_set = *Amanda::Devicec::Device_file_set;
  65 *swig_block_get = *Amanda::Devicec::Device_block_get;
  66 *swig_block_set = *Amanda::Devicec::Device_block_set;
  67 *swig_in_file_get = *Amanda::Devicec::Device_in_file_get;
  68 *swig_in_file_set = *Amanda::Devicec::Device_in_file_set;
  69 *swig_device_name_get = *Amanda::Devicec::Device_device_name_get;
  70 *swig_device_name_set = *Amanda::Devicec::Device_device_name_set;
  71 *swig_access_mode_get = *Amanda::Devicec::Device_access_mode_get;
  72 *swig_access_mode_set = *Amanda::Devicec::Device_access_mode_set;
  73 *swig_is_eof_get = *Amanda::Devicec::Device_is_eof_get;
  74 *swig_is_eof_set = *Amanda::Devicec::Device_is_eof_set;
  75 *swig_volume_label_get = *Amanda::Devicec::Device_volume_label_get;
  76 *swig_volume_label_set = *Amanda::Devicec::Device_volume_label_set;
  77 *swig_volume_time_get = *Amanda::Devicec::Device_volume_time_get;
  78 *swig_volume_time_set = *Amanda::Devicec::Device_volume_time_set;
  79 sub new {
  80     my $pkg = shift;
  81     my $self = Amanda::Devicec::new_Device(@_);
  82     bless $self, $pkg if defined($self);
  83 }
  84
  85 sub DESTROY {
  86     return unless $_[0]->isa('HASH');
  87     my $self = tied(%{$_[0]});
  88     return unless defined $self;
  89     delete $ITERATORS{$self};
  90     if (exists $OWNER{$self}) {
  91         Amanda::Devicec::delete_Device($self);
  92         delete $OWNER{$self};
  93     }
  94 }
  95
  96 *read_label = *Amanda::Devicec::Device_read_label;
  97 *start = *Amanda::Devicec::Device_start;
  98 *finish = *Amanda::Devicec::Device_finish;
  99 *start_file = *Amanda::Devicec::Device_start_file;
 100 *write_min_size = *Amanda::Devicec::Device_write_min_size;
 101 *write_max_size = *Amanda::Devicec::Device_write_max_size;
 102 *read_max_size = *Amanda::Devicec::Device_read_max_size;
 103 *write_block = *Amanda::Devicec::Device_write_block;
 104 *write_from_fd = *Amanda::Devicec::Device_write_from_fd;
 105 *finish_file = *Amanda::Devicec::Device_finish_file;
 106 *seek_file = *Amanda::Devicec::Device_seek_file;
 107 *seek_block = *Amanda::Devicec::Device_seek_block;
 108 *read_block = *Amanda::Devicec::Device_read_block;
 109 *read_to_fd = *Amanda::Devicec::Device_read_to_fd;
 110 *property_list = *Amanda::Devicec::Device_property_list;
 111 *property_get = *Amanda::Devicec::Device_property_get;
 112 *property_set = *Amanda::Devicec::Device_property_set;
 113 *recycle_file = *Amanda::Devicec::Device_recycle_file;
 114 *set_startup_properties_from_config = *Amanda::Devicec::Device_set_startup_properties_from_config;
 115 sub DISOWN {
 116     my $self = shift;
 117     my $ptr = tied(%$self);
 118     delete $OWNER{$ptr};
 119 }
 120
 121 sub ACQUIRE {
 122     my $self = shift;
 123     my $ptr = tied(%$self);
 124     $OWNER{$ptr} = 1;
 125 }
 126
 127
 128 # ------- VARIABLE STUBS --------
 129
 130 package Amanda::Device;
 131
 132 *ACCESS_NULL = *Amanda::Devicec::ACCESS_NULL;
 133 *ACCESS_READ = *Amanda::Devicec::ACCESS_READ;
 134 *ACCESS_WRITE = *Amanda::Devicec::ACCESS_WRITE;
 135 *ACCESS_APPEND = *Amanda::Devicec::ACCESS_APPEND;
 136 *READ_LABEL_STATUS_SUCCESS = *Amanda::Devicec::READ_LABEL_STATUS_SUCCESS;
 137 *READ_LABEL_STATUS_DEVICE_MISSING = *Amanda::Devicec::READ_LABEL_STATUS_DEVICE_MISSING;
 138 *READ_LABEL_STATUS_DEVICE_ERROR = *Amanda::Devicec::READ_LABEL_STATUS_DEVICE_ERROR;
 139 *READ_LABEL_STATUS_VOLUME_MISSING = *Amanda::Devicec::READ_LABEL_STATUS_VOLUME_MISSING;
 140 *READ_LABEL_STATUS_VOLUME_UNLABELED = *Amanda::Devicec::READ_LABEL_STATUS_VOLUME_UNLABELED;
 141 *READ_LABEL_STATUS_VOLUME_ERROR = *Amanda::Devicec::READ_LABEL_STATUS_VOLUME_ERROR;
 142 *READ_LABEL_STATUS_FLAGS_MAX = *Amanda::Devicec::READ_LABEL_STATUS_FLAGS_MAX;
 143 *PROPERTY_PHASE_BEFORE_START = *Amanda::Devicec::PROPERTY_PHASE_BEFORE_START;
 144 *PROPERTY_PHASE_BETWEEN_FILE_WRITE = *Amanda::Devicec::PROPERTY_PHASE_BETWEEN_FILE_WRITE;
 145 *PROPERTY_PHASE_INSIDE_FILE_WRITE = *Amanda::Devicec::PROPERTY_PHASE_INSIDE_FILE_WRITE;
 146 *PROPERTY_PHASE_BETWEEN_FILE_READ = *Amanda::Devicec::PROPERTY_PHASE_BETWEEN_FILE_READ;
 147 *PROPERTY_PHASE_INSIDE_FILE_READ = *Amanda::Devicec::PROPERTY_PHASE_INSIDE_FILE_READ;
 148 *PROPERTY_PHASE_MAX = *Amanda::Devicec::PROPERTY_PHASE_MAX;
 149 *PROPERTY_PHASE_MASK = *Amanda::Devicec::PROPERTY_PHASE_MASK;
 150 *PROPERTY_PHASE_SHIFT = *Amanda::Devicec::PROPERTY_PHASE_SHIFT;
 151 *PROPERTY_ACCESS_GET_BEFORE_START = *Amanda::Devicec::PROPERTY_ACCESS_GET_BEFORE_START;
 152 *PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE = *Amanda::Devicec::PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE;
 153 *PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE = *Amanda::Devicec::PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE;
 154 *PROPERTY_ACCESS_GET_BETWEEN_FILE_READ = *Amanda::Devicec::PROPERTY_ACCESS_GET_BETWEEN_FILE_READ;
 155 *PROPERTY_ACCESS_GET_INSIDE_FILE_READ = *Amanda::Devicec::PROPERTY_ACCESS_GET_INSIDE_FILE_READ;
 156 *PROPERTY_ACCESS_SET_BEFORE_START = *Amanda::Devicec::PROPERTY_ACCESS_SET_BEFORE_START;
 157 *PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE = *Amanda::Devicec::PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE;
 158 *PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE = *Amanda::Devicec::PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE;
 159 *PROPERTY_ACCESS_SET_BETWEEN_FILE_READ = *Amanda::Devicec::PROPERTY_ACCESS_SET_BETWEEN_FILE_READ;
 160 *PROPERTY_ACCESS_SET_INSIDE_FILE_READ = *Amanda::Devicec::PROPERTY_ACCESS_SET_INSIDE_FILE_READ;
 161 *PROPERTY_ACCESS_GET_MASK = *Amanda::Devicec::PROPERTY_ACCESS_GET_MASK;
 162 *PROPERTY_ACCESS_SET_MASK = *Amanda::Devicec::PROPERTY_ACCESS_SET_MASK;
 163 *CONCURRENCY_PARADIGM_EXCLUSIVE = *Amanda::Devicec::CONCURRENCY_PARADIGM_EXCLUSIVE;
 164 *CONCURRENCY_PARADIGM_SHARED_READ = *Amanda::Devicec::CONCURRENCY_PARADIGM_SHARED_READ;
 165 *CONCURRENCY_PARADIGM_RANDOM_ACCESS = *Amanda::Devicec::CONCURRENCY_PARADIGM_RANDOM_ACCESS;
 166 *STREAMING_REQUIREMENT_NONE = *Amanda::Devicec::STREAMING_REQUIREMENT_NONE;
 167 *STREAMING_REQUIREMENT_DESIRED = *Amanda::Devicec::STREAMING_REQUIREMENT_DESIRED;
 168 *STREAMING_REQUIREMENT_REQUIRED = *Amanda::Devicec::STREAMING_REQUIREMENT_REQUIRED;
 169 *MEDIA_ACCESS_MODE_READ_ONLY = *Amanda::Devicec::MEDIA_ACCESS_MODE_READ_ONLY;
 170 *MEDIA_ACCESS_MODE_WORM = *Amanda::Devicec::MEDIA_ACCESS_MODE_WORM;
 171 *MEDIA_ACCESS_MODE_READ_WRITE = *Amanda::Devicec::MEDIA_ACCESS_MODE_READ_WRITE;
 172 *MEDIA_ACCESS_MODE_WRITE_ONLY = *Amanda::Devicec::MEDIA_ACCESS_MODE_WRITE_ONLY;
 173 *SIZE_ACCURACY_UNKNOWN = *Amanda::Devicec::SIZE_ACCURACY_UNKNOWN;
 174 *SIZE_ACCURACY_ESTIMATE = *Amanda::Devicec::SIZE_ACCURACY_ESTIMATE;
 175 *SIZE_ACCURACY_REAL = *Amanda::Devicec::SIZE_ACCURACY_REAL;
 176 *FEATURE_STATUS_ENABLED = *Amanda::Devicec::FEATURE_STATUS_ENABLED;
 177 *FEATURE_STATUS_DISABLED = *Amanda::Devicec::FEATURE_STATUS_DISABLED;
 178 *FEATURE_SURETY_BAD = *Amanda::Devicec::FEATURE_SURETY_BAD;
 179 *FEATURE_SURETY_GOOD = *Amanda::Devicec::FEATURE_SURETY_GOOD;
 180 *FEATURE_SOURCE_DEFAULT = *Amanda::Devicec::FEATURE_SOURCE_DEFAULT;
 181 *FEATURE_SOURCE_DETECTED = *Amanda::Devicec::FEATURE_SOURCE_DETECTED;
 182 *FEATURE_SOURCE_USER = *Amanda::Devicec::FEATURE_SOURCE_USER;
 183 *FEATURE_SUPPORT_FLAGS_MAX = *Amanda::Devicec::FEATURE_SUPPORT_FLAGS_MAX;
 184 *FEATURE_SUPPORT_FLAGS_MASK = *Amanda::Devicec::FEATURE_SUPPORT_FLAGS_MASK;
 185 *FEATURE_SUPPORT_FLAGS_STATUS_MASK = *Amanda::Devicec::FEATURE_SUPPORT_FLAGS_STATUS_MASK;
 186 *FEATURE_SUPPORT_FLAGS_SURETY_MASK = *Amanda::Devicec::FEATURE_SUPPORT_FLAGS_SURETY_MASK;
 187 *FEATURE_SUPPORT_FLAGS_SOURCE_MASK = *Amanda::Devicec::FEATURE_SUPPORT_FLAGS_SOURCE_MASK;
 188
 189 @EXPORT_OK = ();
 190 %EXPORT_TAGS = ();
 191
 192 =head1 NAME
 193
 194 Amanda::Device - interact with Amanda data-storage devices
 195
 196 =head1 SYNOPSIS
 197
 198   use Amanda::Device qw( :constants );
 199
 200   my $dev = Amanda::Device->new($device_name);
 201   $dev->set_startup_properties_from_config();
 202   if ($dev->read_label() == $READ_LABEL_STATUS_SUCCESS) {
 203       print "Label on $device_name is '$dev->volume_label'\n";
 204   }
 205
 206 See http://wiki.zmanda.com/index.php/Device_API for details on how Devices are used.
 207
 208 =head1 API STATUS
 209
 210 Stable
 211
 212 =head1 Amanda::Device Objects
 213
 214 =head2 Instance Variables
 215
 216 =over
 217
 218 =item C<$file>
 219
 220 =item C<$block>
 221
 222 =item C<$in_file>
 223
 224 =item C<$device_name>
 225
 226 =item C<$access_mode>
 227
 228 =item C<$is_eof>
 229
 230 =item C<$volume_label>
 231
 232 =item C<$volume_time>
 233
 234 =back
 235
 236 =head2 Methods
 237
 238 See the wiki for descriptions of these functions
 239
 240 =over
 241
 242 =item C<read_label()>
 243
 244 =item C<start($mode, $label, $timestamp)>
 245
 246 =item C<finish()>
 247
 248 =item C<start_file($jobinfo)>
 249
 250 where C<$jobinfo> is a C<dumpfile_t> (see L<Amanda::Datatypes>)
 251
 252 =item C<write_min_size()>
 253
 254 =item C<write_max_size()>
 255
 256 =item C<read_max_size()>
 257
 258 =item C<write_block($size, $data, $short_block)>
 259
 260 Note that Perl code is not expected to handle on-device data, so there
 261 is currently no way to provide data to this function from Perl.  This may
 262 change in future revisions.
 263
 264 =item C<write_from_fd($fd)>
 265
 266 where C<$fd> is an integer file descriptor, not a filehandle
 267
 268 =item C<finish_file()>
 269
 270 =item C<seek_file($file)>
 271
 272 =item C<seek_block($block)>
 273
 274 =item C<read_block($size)>
 275
 276 =item C<read_to_fd($fd)>
 277
 278 where C<$fd> is an integer file descriptor, not a filehandle
 279
 280 Note that Perl code is not expected to handle on-device data, so there
 281 is currently no way to access the data this function returns.  This may
 282 change in future revisions.
 283
 284 =item C<property_list()>
 285
 286 returns a list of property names.
 287
 288 =item C<property_get($property_name)>
 289
 290 returns the property as the appropriate Perl type.
 291
 292 =item C<property_set($property_name, $value)>
 293
 294 where $value is of an appropriate type for the given property
 295
 296 =item C<recycle_file($filenum)>
 297
 298 =item C<set_startup_properties_from_config()>
 299
 300 =back
 301
 302 =head1 CONSTANTS
 303
 304 This module defines a large number of constants.  Again, consult the
 305 wiki or C<device.h> for the details on their meaning.  These constants
 306 are available from the package namespace (e.g.,
 307 C<Amanda::Device::ACCESS_WRITE>), of imported with the C<:constant>
 308 import tag.
 309
 310 =cut
 311
 312 push @EXPORT_OK, qw(DeviceAccessMode_to_strings);
 313 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw(DeviceAccessMode_to_strings);
 314
 315 my %_DeviceAccessMode_VALUES;
 316 #Convert a flag value to a list of names for flags that are set.
 317 sub DeviceAccessMode_to_strings {
 318     my ($flags) = @_;
 319     my @result = ();
 320
 321     for my $k (keys %_DeviceAccessMode_VALUES) {
 322         my $v = $_DeviceAccessMode_VALUES{$k};
 323
 324         #is this a matching flag?
 325         if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
 326             push @result, $k;
 327         }
 328     }
 329
 330 #by default, just return the number as a 1-element list
 331     if (!@result) {
 332         return ($flags);
 333     }
 334
 335     return @result;
 336 }
 337
 338 push @EXPORT_OK, qw($ACCESS_NULL);
 339 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw($ACCESS_NULL);
 340
 341 $_DeviceAccessMode_VALUES{"NULL"} = $ACCESS_NULL;
 342
 343 push @EXPORT_OK, qw($ACCESS_READ);
 344 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw($ACCESS_READ);
 345
 346 $_DeviceAccessMode_VALUES{"READ"} = $ACCESS_READ;
 347
 348 push @EXPORT_OK, qw($ACCESS_WRITE);
 349 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw($ACCESS_WRITE);
 350
 351 $_DeviceAccessMode_VALUES{"WRITE"} = $ACCESS_WRITE;
 352
 353 push @EXPORT_OK, qw($ACCESS_APPEND);
 354 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw($ACCESS_APPEND);
 355
 356 $_DeviceAccessMode_VALUES{"APPEND"} = $ACCESS_APPEND;
 357
 358 push @EXPORT_OK, qw(IS_WRITABLE_ACCESS_MODE);
 359 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw(IS_WRITABLE_ACCESS_MODE);
 360
 361 #copy symbols in DeviceAccessMode to constants
 362 push @{$EXPORT_TAGS{"constants"}},  @{$EXPORT_TAGS{"DeviceAccessMode"}};
 363
 364 push @EXPORT_OK, qw(ReadLabelStatusFlags_to_strings);
 365 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw(ReadLabelStatusFlags_to_strings);
 366
 367 my %_ReadLabelStatusFlags_VALUES;
 368 #Convert a flag value to a list of names for flags that are set.
 369 sub ReadLabelStatusFlags_to_strings {
 370     my ($flags) = @_;
 371     my @result = ();
 372
 373     for my $k (keys %_ReadLabelStatusFlags_VALUES) {
 374         my $v = $_ReadLabelStatusFlags_VALUES{$k};
 375
 376         #is this a matching flag?
 377         if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
 378             push @result, $k;
 379         }
 380     }
 381
 382 #by default, just return the number as a 1-element list
 383     if (!@result) {
 384         return ($flags);
 385     }
 386
 387     return @result;
 388 }
 389
 390 push @EXPORT_OK, qw($READ_LABEL_STATUS_SUCCESS);
 391 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_SUCCESS);
 392
 393 $_ReadLabelStatusFlags_VALUES{"SUCCESS"} = $READ_LABEL_STATUS_SUCCESS;
 394
 395 push @EXPORT_OK, qw($READ_LABEL_STATUS_DEVICE_MISSING);
 396 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_DEVICE_MISSING);
 397
 398 $_ReadLabelStatusFlags_VALUES{"DEVICE_MISSING"} = $READ_LABEL_STATUS_DEVICE_MISSING;
 399
 400 push @EXPORT_OK, qw($READ_LABEL_STATUS_DEVICE_ERROR);
 401 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_DEVICE_ERROR);
 402
 403 $_ReadLabelStatusFlags_VALUES{"DEVICE_ERROR"} = $READ_LABEL_STATUS_DEVICE_ERROR;
 404
 405 push @EXPORT_OK, qw($READ_LABEL_STATUS_VOLUME_MISSING);
 406 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_VOLUME_MISSING);
 407
 408 $_ReadLabelStatusFlags_VALUES{"VOLUME_MISSING"} = $READ_LABEL_STATUS_VOLUME_MISSING;
 409
 410 push @EXPORT_OK, qw($READ_LABEL_STATUS_VOLUME_UNLABELED);
 411 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_VOLUME_UNLABELED);
 412
 413 $_ReadLabelStatusFlags_VALUES{"VOLUME_UNLABELED"} = $READ_LABEL_STATUS_VOLUME_UNLABELED;
 414
 415 push @EXPORT_OK, qw($READ_LABEL_STATUS_VOLUME_ERROR);
 416 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_VOLUME_ERROR);
 417
 418 $_ReadLabelStatusFlags_VALUES{"VOLUME_ERROR"} = $READ_LABEL_STATUS_VOLUME_ERROR;
 419
 420 push @EXPORT_OK, qw($READ_LABEL_STATUS_FLAGS_MAX);
 421 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_FLAGS_MAX);
 422
 423 #copy symbols in ReadLabelStatusFlags to constants
 424 push @{$EXPORT_TAGS{"constants"}},  @{$EXPORT_TAGS{"ReadLabelStatusFlags"}};
 425
 426 push @EXPORT_OK, qw(PropertyPhaseFlags_to_strings);
 427 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw(PropertyPhaseFlags_to_strings);
 428
 429 my %_PropertyPhaseFlags_VALUES;
 430 #Convert a flag value to a list of names for flags that are set.
 431 sub PropertyPhaseFlags_to_strings {
 432     my ($flags) = @_;
 433     my @result = ();
 434
 435     for my $k (keys %_PropertyPhaseFlags_VALUES) {
 436         my $v = $_PropertyPhaseFlags_VALUES{$k};
 437
 438         #is this a matching flag?
 439         if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
 440             push @result, $k;
 441         }
 442     }
 443
 444 #by default, just return the number as a 1-element list
 445     if (!@result) {
 446         return ($flags);
 447     }
 448
 449     return @result;
 450 }
 451
 452 push @EXPORT_OK, qw($PROPERTY_PHASE_BEFORE_START);
 453 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_BEFORE_START);
 454
 455 $_PropertyPhaseFlags_VALUES{"BEFORE_START"} = $PROPERTY_PHASE_BEFORE_START;
 456
 457 push @EXPORT_OK, qw($PROPERTY_PHASE_BETWEEN_FILE_WRITE);
 458 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_BETWEEN_FILE_WRITE);
 459
 460 $_PropertyPhaseFlags_VALUES{"BETWEEN_FILE_WRITE"} = $PROPERTY_PHASE_BETWEEN_FILE_WRITE;
 461
 462 push @EXPORT_OK, qw($PROPERTY_PHASE_INSIDE_FILE_WRITE);
 463 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_INSIDE_FILE_WRITE);
 464
 465 $_PropertyPhaseFlags_VALUES{"INSIDE_FILE_WRITE"} = $PROPERTY_PHASE_INSIDE_FILE_WRITE;
 466
 467 push @EXPORT_OK, qw($PROPERTY_PHASE_BETWEEN_FILE_READ);
 468 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_BETWEEN_FILE_READ);
 469
 470 $_PropertyPhaseFlags_VALUES{"BETWEEN_FILE_READ"} = $PROPERTY_PHASE_BETWEEN_FILE_READ;
 471
 472 push @EXPORT_OK, qw($PROPERTY_PHASE_INSIDE_FILE_READ);
 473 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_INSIDE_FILE_READ);
 474
 475 $_PropertyPhaseFlags_VALUES{"INSIDE_FILE_READ"} = $PROPERTY_PHASE_INSIDE_FILE_READ;
 476
 477 push @EXPORT_OK, qw($PROPERTY_PHASE_MAX);
 478 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_MAX);
 479
 480 push @EXPORT_OK, qw($PROPERTY_PHASE_MASK);
 481 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_MASK);
 482
 483 push @EXPORT_OK, qw($PROPERTY_PHASE_SHIFT);
 484 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_SHIFT);
 485
 486 #copy symbols in PropertyPhaseFlags to constants
 487 push @{$EXPORT_TAGS{"constants"}},  @{$EXPORT_TAGS{"PropertyPhaseFlags"}};
 488
 489 push @EXPORT_OK, qw(PropertyAccessFlags_to_strings);
 490 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw(PropertyAccessFlags_to_strings);
 491
 492 my %_PropertyAccessFlags_VALUES;
 493 #Convert a flag value to a list of names for flags that are set.
 494 sub PropertyAccessFlags_to_strings {
 495     my ($flags) = @_;
 496     my @result = ();
 497
 498     for my $k (keys %_PropertyAccessFlags_VALUES) {
 499         my $v = $_PropertyAccessFlags_VALUES{$k};
 500
 501         #is this a matching flag?
 502         if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
 503             push @result, $k;
 504         }
 505     }
 506
 507 #by default, just return the number as a 1-element list
 508     if (!@result) {
 509         return ($flags);
 510     }
 511
 512     return @result;
 513 }
 514
 515 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_BEFORE_START);
 516 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_BEFORE_START);
 517
 518 $_PropertyAccessFlags_VALUES{"GET_BEFORE_START"} = $PROPERTY_ACCESS_GET_BEFORE_START;
 519
 520 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE);
 521 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE);
 522
 523 $_PropertyAccessFlags_VALUES{"GET_BETWEEN_FILE_WRITE"} = $PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE;
 524
 525 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE);
 526 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE);
 527
 528 $_PropertyAccessFlags_VALUES{"GET_INSIDE_FILE_WRITE"} = $PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE;
 529
 530 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_BETWEEN_FILE_READ);
 531 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_BETWEEN_FILE_READ);
 532
 533 $_PropertyAccessFlags_VALUES{"GET_BETWEEN_FILE_READ"} = $PROPERTY_ACCESS_GET_BETWEEN_FILE_READ;
 534
 535 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_INSIDE_FILE_READ);
 536 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_INSIDE_FILE_READ);
 537
 538 $_PropertyAccessFlags_VALUES{"GET_INSIDE_FILE_READ"} = $PROPERTY_ACCESS_GET_INSIDE_FILE_READ;
 539
 540 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_BEFORE_START);
 541 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_BEFORE_START);
 542
 543 $_PropertyAccessFlags_VALUES{"SET_BEFORE_START"} = $PROPERTY_ACCESS_SET_BEFORE_START;
 544
 545 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE);
 546 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE);
 547
 548 $_PropertyAccessFlags_VALUES{"SET_BETWEEN_FILE_WRITE"} = $PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE;
 549
 550 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE);
 551 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE);
 552
 553 $_PropertyAccessFlags_VALUES{"SET_INSIDE_FILE_WRITE"} = $PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE;
 554
 555 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_BETWEEN_FILE_READ);
 556 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_BETWEEN_FILE_READ);
 557
 558 $_PropertyAccessFlags_VALUES{"SET_BETWEEN_FILE_READ"} = $PROPERTY_ACCESS_SET_BETWEEN_FILE_READ;
 559
 560 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_INSIDE_FILE_READ);
 561 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_INSIDE_FILE_READ);
 562
 563 $_PropertyAccessFlags_VALUES{"SET_INSIDE_FILE_READ"} = $PROPERTY_ACCESS_SET_INSIDE_FILE_READ;
 564
 565 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_MASK);
 566 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_MASK);
 567
 568 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_MASK);
 569 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_MASK);
 570
 571 #copy symbols in PropertyAccessFlags to constants
 572 push @{$EXPORT_TAGS{"constants"}},  @{$EXPORT_TAGS{"PropertyAccessFlags"}};
 573
 574 push @EXPORT_OK, qw(ConcurrencyParadigm_to_string);
 575 push @{$EXPORT_TAGS{"ConcurrencyParadigm"}}, qw(ConcurrencyParadigm_to_string);
 576
 577 my %_ConcurrencyParadigm_VALUES;
 578 #Convert an enum value to a single string
 579 sub ConcurrencyParadigm_to_string {
 580     my ($enumval) = @_;
 581
 582     for my $k (keys %_ConcurrencyParadigm_VALUES) {
 583         my $v = $_ConcurrencyParadigm_VALUES{$k};
 584
 585         #is this a matching flag?
 586         if ($enumval == $v) {
 587             return $k;
 588         }
 589     }
 590
 591 #default, just return the number
 592     return $enumval;
 593 }
 594
 595 push @EXPORT_OK, qw($CONCURRENCY_PARADIGM_EXCLUSIVE);
 596 push @{$EXPORT_TAGS{"ConcurrencyParadigm"}}, qw($CONCURRENCY_PARADIGM_EXCLUSIVE);
 597
 598 $_ConcurrencyParadigm_VALUES{"EXCLUSIVE"} = $CONCURRENCY_PARADIGM_EXCLUSIVE;
 599
 600 push @EXPORT_OK, qw($CONCURRENCY_PARADIGM_SHARED_READ);
 601 push @{$EXPORT_TAGS{"ConcurrencyParadigm"}}, qw($CONCURRENCY_PARADIGM_SHARED_READ);
 602
 603 $_ConcurrencyParadigm_VALUES{"SHARED_READ"} = $CONCURRENCY_PARADIGM_SHARED_READ;
 604
 605 push @EXPORT_OK, qw($CONCURRENCY_PARADIGM_RANDOM_ACCESS);
 606 push @{$EXPORT_TAGS{"ConcurrencyParadigm"}}, qw($CONCURRENCY_PARADIGM_RANDOM_ACCESS);
 607
 608 $_ConcurrencyParadigm_VALUES{"RANDOM_ACCESS"} = $CONCURRENCY_PARADIGM_RANDOM_ACCESS;
 609
 610 #copy symbols in ConcurrencyParadigm to constants
 611 push @{$EXPORT_TAGS{"constants"}},  @{$EXPORT_TAGS{"ConcurrencyParadigm"}};
 612
 613 push @EXPORT_OK, qw(StreamingRequirement_to_string);
 614 push @{$EXPORT_TAGS{"StreamingRequirement"}}, qw(StreamingRequirement_to_string);
 615
 616 my %_StreamingRequirement_VALUES;
 617 #Convert an enum value to a single string
 618 sub StreamingRequirement_to_string {
 619     my ($enumval) = @_;
 620
 621     for my $k (keys %_StreamingRequirement_VALUES) {
 622         my $v = $_StreamingRequirement_VALUES{$k};
 623
 624         #is this a matching flag?
 625         if ($enumval == $v) {
 626             return $k;
 627         }
 628     }
 629
 630 #default, just return the number
 631     return $enumval;
 632 }
 633
 634 push @EXPORT_OK, qw($STREAMING_REQUIREMENT_NONE);
 635 push @{$EXPORT_TAGS{"StreamingRequirement"}}, qw($STREAMING_REQUIREMENT_NONE);
 636
 637 $_StreamingRequirement_VALUES{"NONE"} = $STREAMING_REQUIREMENT_NONE;
 638
 639 push @EXPORT_OK, qw($STREAMING_REQUIREMENT_DESIRED);
 640 push @{$EXPORT_TAGS{"StreamingRequirement"}}, qw($STREAMING_REQUIREMENT_DESIRED);
 641
 642 $_StreamingRequirement_VALUES{"DESIRED"} = $STREAMING_REQUIREMENT_DESIRED;
 643
 644 push @EXPORT_OK, qw($STREAMING_REQUIREMENT_REQUIRED);
 645 push @{$EXPORT_TAGS{"StreamingRequirement"}}, qw($STREAMING_REQUIREMENT_REQUIRED);
 646
 647 $_StreamingRequirement_VALUES{"REQUIRED"} = $STREAMING_REQUIREMENT_REQUIRED;
 648
 649 #copy symbols in StreamingRequirement to constants
 650 push @{$EXPORT_TAGS{"constants"}},  @{$EXPORT_TAGS{"StreamingRequirement"}};
 651
 652 push @EXPORT_OK, qw(MediaAccessMode_to_string);
 653 push @{$EXPORT_TAGS{"MediaAccessMode"}}, qw(MediaAccessMode_to_string);
 654
 655 my %_MediaAccessMode_VALUES;
 656 #Convert an enum value to a single string
 657 sub MediaAccessMode_to_string {
 658     my ($enumval) = @_;
 659
 660     for my $k (keys %_MediaAccessMode_VALUES) {
 661         my $v = $_MediaAccessMode_VALUES{$k};
 662
 663         #is this a matching flag?
 664         if ($enumval == $v) {
 665             return $k;
 666         }
 667     }
 668
 669 #default, just return the number
 670     return $enumval;
 671 }
 672
 673 push @EXPORT_OK, qw($MEDIA_ACCESS_MODE_READ_ONLY);
 674 push @{$EXPORT_TAGS{"MediaAccessMode"}}, qw($MEDIA_ACCESS_MODE_READ_ONLY);
 675
 676 $_MediaAccessMode_VALUES{"READ_ONLY"} = $MEDIA_ACCESS_MODE_READ_ONLY;
 677
 678 push @EXPORT_OK, qw($MEDIA_ACCESS_MODE_WORM);
 679 push @{$EXPORT_TAGS{"MediaAccessMode"}}, qw($MEDIA_ACCESS_MODE_WORM);
 680
 681 $_MediaAccessMode_VALUES{"WORM"} = $MEDIA_ACCESS_MODE_WORM;
 682
 683 push @EXPORT_OK, qw($MEDIA_ACCESS_MODE_READ_WRITE);
 684 push @{$EXPORT_TAGS{"MediaAccessMode"}}, qw($MEDIA_ACCESS_MODE_READ_WRITE);
 685
 686 $_MediaAccessMode_VALUES{"READ_WRITE"} = $MEDIA_ACCESS_MODE_READ_WRITE;
 687
 688 push @EXPORT_OK, qw($MEDIA_ACCESS_MODE_WRITE_ONLY);
 689 push @{$EXPORT_TAGS{"MediaAccessMode"}}, qw($MEDIA_ACCESS_MODE_WRITE_ONLY);
 690
 691 $_MediaAccessMode_VALUES{"WRITE_ONLY"} = $MEDIA_ACCESS_MODE_WRITE_ONLY;
 692
 693 #copy symbols in MediaAccessMode to constants
 694 push @{$EXPORT_TAGS{"constants"}},  @{$EXPORT_TAGS{"MediaAccessMode"}};
 695
 696 push @EXPORT_OK, qw(SizeAccuracy_to_string);
 697 push @{$EXPORT_TAGS{"SizeAccuracy"}}, qw(SizeAccuracy_to_string);
 698
 699 my %_SizeAccuracy_VALUES;
 700 #Convert an enum value to a single string
 701 sub SizeAccuracy_to_string {
 702     my ($enumval) = @_;
 703
 704     for my $k (keys %_SizeAccuracy_VALUES) {
 705         my $v = $_SizeAccuracy_VALUES{$k};
 706
 707         #is this a matching flag?
 708         if ($enumval == $v) {
 709             return $k;
 710         }
 711     }
 712
 713 #default, just return the number
 714     return $enumval;
 715 }
 716
 717 push @EXPORT_OK, qw($SIZE_ACCURACY_UNKNOWN);
 718 push @{$EXPORT_TAGS{"SizeAccuracy"}}, qw($SIZE_ACCURACY_UNKNOWN);
 719
 720 $_SizeAccuracy_VALUES{"UNKNOWN"} = $SIZE_ACCURACY_UNKNOWN;
 721
 722 push @EXPORT_OK, qw($SIZE_ACCURACY_ESTIMATE);
 723 push @{$EXPORT_TAGS{"SizeAccuracy"}}, qw($SIZE_ACCURACY_ESTIMATE);
 724
 725 $_SizeAccuracy_VALUES{"ESTIMATE"} = $SIZE_ACCURACY_ESTIMATE;
 726
 727 push @EXPORT_OK, qw($SIZE_ACCURACY_REAL);
 728 push @{$EXPORT_TAGS{"SizeAccuracy"}}, qw($SIZE_ACCURACY_REAL);
 729
 730 $_SizeAccuracy_VALUES{"REAL"} = $SIZE_ACCURACY_REAL;
 731
 732 #copy symbols in SizeAccuracy to constants
 733 push @{$EXPORT_TAGS{"constants"}},  @{$EXPORT_TAGS{"SizeAccuracy"}};
 734
 735 push @EXPORT_OK, qw(FeatureSupportFlags_to_strings);
 736 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw(FeatureSupportFlags_to_strings);
 737
 738 my %_FeatureSupportFlags_VALUES;
 739 #Convert a flag value to a list of names for flags that are set.
 740 sub FeatureSupportFlags_to_strings {
 741     my ($flags) = @_;
 742     my @result = ();
 743
 744     for my $k (keys %_FeatureSupportFlags_VALUES) {
 745         my $v = $_FeatureSupportFlags_VALUES{$k};
 746
 747         #is this a matching flag?
 748         if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
 749             push @result, $k;
 750         }
 751     }
 752
 753 #by default, just return the number as a 1-element list
 754     if (!@result) {
 755         return ($flags);
 756     }
 757
 758     return @result;
 759 }
 760
 761 push @EXPORT_OK, qw($FEATURE_STATUS_ENABLED);
 762 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_STATUS_ENABLED);
 763
 764 $_FeatureSupportFlags_VALUES{"STATUS_ENABLED"} = $FEATURE_STATUS_ENABLED;
 765
 766 push @EXPORT_OK, qw($FEATURE_STATUS_DISABLED);
 767 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_STATUS_DISABLED);
 768
 769 $_FeatureSupportFlags_VALUES{"STATUS_DISABLED"} = $FEATURE_STATUS_DISABLED;
 770
 771 push @EXPORT_OK, qw($FEATURE_SURETY_BAD);
 772 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SURETY_BAD);
 773
 774 $_FeatureSupportFlags_VALUES{"SURETY_BAD"} = $FEATURE_SURETY_BAD;
 775
 776 push @EXPORT_OK, qw($FEATURE_SURETY_GOOD);
 777 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SURETY_GOOD);
 778
 779 $_FeatureSupportFlags_VALUES{"SURETY_GOOD"} = $FEATURE_SURETY_GOOD;
 780
 781 push @EXPORT_OK, qw($FEATURE_SOURCE_DEFAULT);
 782 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SOURCE_DEFAULT);
 783
 784 $_FeatureSupportFlags_VALUES{"SOURCE_DEFAULT"} = $FEATURE_SOURCE_DEFAULT;
 785
 786 push @EXPORT_OK, qw($FEATURE_SOURCE_DETECTED);
 787 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SOURCE_DETECTED);
 788
 789 $_FeatureSupportFlags_VALUES{"SOURCE_DETECTED"} = $FEATURE_SOURCE_DETECTED;
 790
 791 push @EXPORT_OK, qw($FEATURE_SOURCE_USER);
 792 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SOURCE_USER);
 793
 794 $_FeatureSupportFlags_VALUES{"SOURCE_USER"} = $FEATURE_SOURCE_USER;
 795
 796 push @EXPORT_OK, qw($FEATURE_SUPPORT_FLAGS_MAX);
 797 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SUPPORT_FLAGS_MAX);
 798
 799 push @EXPORT_OK, qw($FEATURE_SUPPORT_FLAGS_MASK);
 800 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SUPPORT_FLAGS_MASK);
 801
 802 push @EXPORT_OK, qw($FEATURE_SUPPORT_FLAGS_STATUS_MASK);
 803 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SUPPORT_FLAGS_STATUS_MASK);
 804
 805 push @EXPORT_OK, qw($FEATURE_SUPPORT_FLAGS_SURETY_MASK);
 806 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SUPPORT_FLAGS_SURETY_MASK);
 807
 808 push @EXPORT_OK, qw($FEATURE_SUPPORT_FLAGS_SOURCE_MASK);
 809 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SUPPORT_FLAGS_SOURCE_MASK);
 810
 811 push @EXPORT_OK, qw(feature_support_flags_is_valid);
 812 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw(feature_support_flags_is_valid);
 813
 814 #copy symbols in FeatureSupportFlags to constants
 815 push @{$EXPORT_TAGS{"constants"}},  @{$EXPORT_TAGS{"FeatureSupportFlags"}};
 816
 817
 818 # SWIG produces a sub-package for the Device "class", in this case named
 819 # Amanda::Device::Device.  For user convenience, we allow Amanda::Device->new(..) to
 820 # do the same thing.  This is a wrapper function, and not just a typeglob assignment,
 821 # because we want to get the right blessing.
 822 sub new {
 823     my $pkg = shift;
 824     Amanda::Device::Device->new(@_);
 825 }
 826 1;