1 # This file was automatically generated by SWIG (http://www.swig.org).
4 # Don't modify this file, modify the SWIG interface instead.
6 package Amanda::Device;
9 @ISA = qw(Exporter DynaLoader);
10 require Amanda::Types;
11 package Amanda::Devicec;
12 bootstrap Amanda::Device;
13 package Amanda::Device;
16 # ---------- BASE METHODS -------------
18 package Amanda::Device;
21 my ($classname,$obj) = @_;
22 return bless $obj, $classname;
32 my ($self,$field) = @_;
33 my $member_func = "swig_${field}_get";
34 $self->$member_func();
38 my ($self,$field,$newval) = @_;
39 my $member_func = "swig_${field}_set";
40 $self->$member_func($newval);
49 # ------- FUNCTION WRAPPERS --------
51 package Amanda::Device;
53 *IS_WRITABLE_ACCESS_MODE = *Amanda::Devicec::IS_WRITABLE_ACCESS_MODE;
54 *feature_support_flags_is_valid = *Amanda::Devicec::feature_support_flags_is_valid;
56 ############# Class : Amanda::Device::Device ##############
58 package Amanda::Device::Device;
59 use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
60 @ISA = qw( Amanda::Device );
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;
81 my $self = Amanda::Devicec::new_Device(@_);
82 bless $self, $pkg if defined($self);
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);
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;
117 my $ptr = tied(%$self);
123 my $ptr = tied(%$self);
128 # ------- VARIABLE STUBS --------
130 package Amanda::Device;
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;
194 Amanda::Device - interact with Amanda data-storage devices
198 use Amanda::Device qw( :constants );
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";
206 See http://wiki.zmanda.com/index.php/Device_API for details on how Devices are used.
212 =head1 Amanda::Device Objects
214 =head2 Instance Variables
224 =item C<$device_name>
226 =item C<$access_mode>
230 =item C<$volume_label>
232 =item C<$volume_time>
238 See the wiki for descriptions of these functions
242 =item C<read_label()>
244 =item C<start($mode, $label, $timestamp)>
248 =item C<start_file($jobinfo)>
250 where C<$jobinfo> is a C<dumpfile_t> (see L<Amanda::Datatypes>)
252 =item C<write_min_size()>
254 =item C<write_max_size()>
256 =item C<read_max_size()>
258 =item C<write_block($size, $data, $short_block)>
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.
264 =item C<write_from_fd($fd)>
266 where C<$fd> is an integer file descriptor, not a filehandle
268 =item C<finish_file()>
270 =item C<seek_file($file)>
272 =item C<seek_block($block)>
274 =item C<read_block($size)>
276 =item C<read_to_fd($fd)>
278 where C<$fd> is an integer file descriptor, not a filehandle
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.
284 =item C<property_list()>
286 returns a list of property names.
288 =item C<property_get($property_name)>
290 returns the property as the appropriate Perl type.
292 =item C<property_set($property_name, $value)>
294 where $value is of an appropriate type for the given property
296 =item C<recycle_file($filenum)>
298 =item C<set_startup_properties_from_config()>
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>
312 push @EXPORT_OK, qw(DeviceAccessMode_to_strings);
313 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw(DeviceAccessMode_to_strings);
315 my %_DeviceAccessMode_VALUES;
316 #Convert a flag value to a list of names for flags that are set.
317 sub DeviceAccessMode_to_strings {
321 for my $k (keys %_DeviceAccessMode_VALUES) {
322 my $v = $_DeviceAccessMode_VALUES{$k};
324 #is this a matching flag?
325 if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
330 #by default, just return the number as a 1-element list
338 push @EXPORT_OK, qw($ACCESS_NULL);
339 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw($ACCESS_NULL);
341 $_DeviceAccessMode_VALUES{"NULL"} = $ACCESS_NULL;
343 push @EXPORT_OK, qw($ACCESS_READ);
344 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw($ACCESS_READ);
346 $_DeviceAccessMode_VALUES{"READ"} = $ACCESS_READ;
348 push @EXPORT_OK, qw($ACCESS_WRITE);
349 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw($ACCESS_WRITE);
351 $_DeviceAccessMode_VALUES{"WRITE"} = $ACCESS_WRITE;
353 push @EXPORT_OK, qw($ACCESS_APPEND);
354 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw($ACCESS_APPEND);
356 $_DeviceAccessMode_VALUES{"APPEND"} = $ACCESS_APPEND;
358 push @EXPORT_OK, qw(IS_WRITABLE_ACCESS_MODE);
359 push @{$EXPORT_TAGS{"DeviceAccessMode"}}, qw(IS_WRITABLE_ACCESS_MODE);
361 #copy symbols in DeviceAccessMode to constants
362 push @{$EXPORT_TAGS{"constants"}}, @{$EXPORT_TAGS{"DeviceAccessMode"}};
364 push @EXPORT_OK, qw(ReadLabelStatusFlags_to_strings);
365 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw(ReadLabelStatusFlags_to_strings);
367 my %_ReadLabelStatusFlags_VALUES;
368 #Convert a flag value to a list of names for flags that are set.
369 sub ReadLabelStatusFlags_to_strings {
373 for my $k (keys %_ReadLabelStatusFlags_VALUES) {
374 my $v = $_ReadLabelStatusFlags_VALUES{$k};
376 #is this a matching flag?
377 if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
382 #by default, just return the number as a 1-element list
390 push @EXPORT_OK, qw($READ_LABEL_STATUS_SUCCESS);
391 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_SUCCESS);
393 $_ReadLabelStatusFlags_VALUES{"SUCCESS"} = $READ_LABEL_STATUS_SUCCESS;
395 push @EXPORT_OK, qw($READ_LABEL_STATUS_DEVICE_MISSING);
396 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_DEVICE_MISSING);
398 $_ReadLabelStatusFlags_VALUES{"DEVICE_MISSING"} = $READ_LABEL_STATUS_DEVICE_MISSING;
400 push @EXPORT_OK, qw($READ_LABEL_STATUS_DEVICE_ERROR);
401 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_DEVICE_ERROR);
403 $_ReadLabelStatusFlags_VALUES{"DEVICE_ERROR"} = $READ_LABEL_STATUS_DEVICE_ERROR;
405 push @EXPORT_OK, qw($READ_LABEL_STATUS_VOLUME_MISSING);
406 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_VOLUME_MISSING);
408 $_ReadLabelStatusFlags_VALUES{"VOLUME_MISSING"} = $READ_LABEL_STATUS_VOLUME_MISSING;
410 push @EXPORT_OK, qw($READ_LABEL_STATUS_VOLUME_UNLABELED);
411 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_VOLUME_UNLABELED);
413 $_ReadLabelStatusFlags_VALUES{"VOLUME_UNLABELED"} = $READ_LABEL_STATUS_VOLUME_UNLABELED;
415 push @EXPORT_OK, qw($READ_LABEL_STATUS_VOLUME_ERROR);
416 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_VOLUME_ERROR);
418 $_ReadLabelStatusFlags_VALUES{"VOLUME_ERROR"} = $READ_LABEL_STATUS_VOLUME_ERROR;
420 push @EXPORT_OK, qw($READ_LABEL_STATUS_FLAGS_MAX);
421 push @{$EXPORT_TAGS{"ReadLabelStatusFlags"}}, qw($READ_LABEL_STATUS_FLAGS_MAX);
423 #copy symbols in ReadLabelStatusFlags to constants
424 push @{$EXPORT_TAGS{"constants"}}, @{$EXPORT_TAGS{"ReadLabelStatusFlags"}};
426 push @EXPORT_OK, qw(PropertyPhaseFlags_to_strings);
427 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw(PropertyPhaseFlags_to_strings);
429 my %_PropertyPhaseFlags_VALUES;
430 #Convert a flag value to a list of names for flags that are set.
431 sub PropertyPhaseFlags_to_strings {
435 for my $k (keys %_PropertyPhaseFlags_VALUES) {
436 my $v = $_PropertyPhaseFlags_VALUES{$k};
438 #is this a matching flag?
439 if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
444 #by default, just return the number as a 1-element list
452 push @EXPORT_OK, qw($PROPERTY_PHASE_BEFORE_START);
453 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_BEFORE_START);
455 $_PropertyPhaseFlags_VALUES{"BEFORE_START"} = $PROPERTY_PHASE_BEFORE_START;
457 push @EXPORT_OK, qw($PROPERTY_PHASE_BETWEEN_FILE_WRITE);
458 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_BETWEEN_FILE_WRITE);
460 $_PropertyPhaseFlags_VALUES{"BETWEEN_FILE_WRITE"} = $PROPERTY_PHASE_BETWEEN_FILE_WRITE;
462 push @EXPORT_OK, qw($PROPERTY_PHASE_INSIDE_FILE_WRITE);
463 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_INSIDE_FILE_WRITE);
465 $_PropertyPhaseFlags_VALUES{"INSIDE_FILE_WRITE"} = $PROPERTY_PHASE_INSIDE_FILE_WRITE;
467 push @EXPORT_OK, qw($PROPERTY_PHASE_BETWEEN_FILE_READ);
468 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_BETWEEN_FILE_READ);
470 $_PropertyPhaseFlags_VALUES{"BETWEEN_FILE_READ"} = $PROPERTY_PHASE_BETWEEN_FILE_READ;
472 push @EXPORT_OK, qw($PROPERTY_PHASE_INSIDE_FILE_READ);
473 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_INSIDE_FILE_READ);
475 $_PropertyPhaseFlags_VALUES{"INSIDE_FILE_READ"} = $PROPERTY_PHASE_INSIDE_FILE_READ;
477 push @EXPORT_OK, qw($PROPERTY_PHASE_MAX);
478 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_MAX);
480 push @EXPORT_OK, qw($PROPERTY_PHASE_MASK);
481 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_MASK);
483 push @EXPORT_OK, qw($PROPERTY_PHASE_SHIFT);
484 push @{$EXPORT_TAGS{"PropertyPhaseFlags"}}, qw($PROPERTY_PHASE_SHIFT);
486 #copy symbols in PropertyPhaseFlags to constants
487 push @{$EXPORT_TAGS{"constants"}}, @{$EXPORT_TAGS{"PropertyPhaseFlags"}};
489 push @EXPORT_OK, qw(PropertyAccessFlags_to_strings);
490 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw(PropertyAccessFlags_to_strings);
492 my %_PropertyAccessFlags_VALUES;
493 #Convert a flag value to a list of names for flags that are set.
494 sub PropertyAccessFlags_to_strings {
498 for my $k (keys %_PropertyAccessFlags_VALUES) {
499 my $v = $_PropertyAccessFlags_VALUES{$k};
501 #is this a matching flag?
502 if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
507 #by default, just return the number as a 1-element list
515 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_BEFORE_START);
516 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_BEFORE_START);
518 $_PropertyAccessFlags_VALUES{"GET_BEFORE_START"} = $PROPERTY_ACCESS_GET_BEFORE_START;
520 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE);
521 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE);
523 $_PropertyAccessFlags_VALUES{"GET_BETWEEN_FILE_WRITE"} = $PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE;
525 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE);
526 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE);
528 $_PropertyAccessFlags_VALUES{"GET_INSIDE_FILE_WRITE"} = $PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE;
530 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_BETWEEN_FILE_READ);
531 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_BETWEEN_FILE_READ);
533 $_PropertyAccessFlags_VALUES{"GET_BETWEEN_FILE_READ"} = $PROPERTY_ACCESS_GET_BETWEEN_FILE_READ;
535 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_INSIDE_FILE_READ);
536 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_INSIDE_FILE_READ);
538 $_PropertyAccessFlags_VALUES{"GET_INSIDE_FILE_READ"} = $PROPERTY_ACCESS_GET_INSIDE_FILE_READ;
540 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_BEFORE_START);
541 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_BEFORE_START);
543 $_PropertyAccessFlags_VALUES{"SET_BEFORE_START"} = $PROPERTY_ACCESS_SET_BEFORE_START;
545 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE);
546 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE);
548 $_PropertyAccessFlags_VALUES{"SET_BETWEEN_FILE_WRITE"} = $PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE;
550 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE);
551 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE);
553 $_PropertyAccessFlags_VALUES{"SET_INSIDE_FILE_WRITE"} = $PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE;
555 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_BETWEEN_FILE_READ);
556 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_BETWEEN_FILE_READ);
558 $_PropertyAccessFlags_VALUES{"SET_BETWEEN_FILE_READ"} = $PROPERTY_ACCESS_SET_BETWEEN_FILE_READ;
560 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_INSIDE_FILE_READ);
561 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_INSIDE_FILE_READ);
563 $_PropertyAccessFlags_VALUES{"SET_INSIDE_FILE_READ"} = $PROPERTY_ACCESS_SET_INSIDE_FILE_READ;
565 push @EXPORT_OK, qw($PROPERTY_ACCESS_GET_MASK);
566 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_GET_MASK);
568 push @EXPORT_OK, qw($PROPERTY_ACCESS_SET_MASK);
569 push @{$EXPORT_TAGS{"PropertyAccessFlags"}}, qw($PROPERTY_ACCESS_SET_MASK);
571 #copy symbols in PropertyAccessFlags to constants
572 push @{$EXPORT_TAGS{"constants"}}, @{$EXPORT_TAGS{"PropertyAccessFlags"}};
574 push @EXPORT_OK, qw(ConcurrencyParadigm_to_string);
575 push @{$EXPORT_TAGS{"ConcurrencyParadigm"}}, qw(ConcurrencyParadigm_to_string);
577 my %_ConcurrencyParadigm_VALUES;
578 #Convert an enum value to a single string
579 sub ConcurrencyParadigm_to_string {
582 for my $k (keys %_ConcurrencyParadigm_VALUES) {
583 my $v = $_ConcurrencyParadigm_VALUES{$k};
585 #is this a matching flag?
586 if ($enumval == $v) {
591 #default, just return the number
595 push @EXPORT_OK, qw($CONCURRENCY_PARADIGM_EXCLUSIVE);
596 push @{$EXPORT_TAGS{"ConcurrencyParadigm"}}, qw($CONCURRENCY_PARADIGM_EXCLUSIVE);
598 $_ConcurrencyParadigm_VALUES{"EXCLUSIVE"} = $CONCURRENCY_PARADIGM_EXCLUSIVE;
600 push @EXPORT_OK, qw($CONCURRENCY_PARADIGM_SHARED_READ);
601 push @{$EXPORT_TAGS{"ConcurrencyParadigm"}}, qw($CONCURRENCY_PARADIGM_SHARED_READ);
603 $_ConcurrencyParadigm_VALUES{"SHARED_READ"} = $CONCURRENCY_PARADIGM_SHARED_READ;
605 push @EXPORT_OK, qw($CONCURRENCY_PARADIGM_RANDOM_ACCESS);
606 push @{$EXPORT_TAGS{"ConcurrencyParadigm"}}, qw($CONCURRENCY_PARADIGM_RANDOM_ACCESS);
608 $_ConcurrencyParadigm_VALUES{"RANDOM_ACCESS"} = $CONCURRENCY_PARADIGM_RANDOM_ACCESS;
610 #copy symbols in ConcurrencyParadigm to constants
611 push @{$EXPORT_TAGS{"constants"}}, @{$EXPORT_TAGS{"ConcurrencyParadigm"}};
613 push @EXPORT_OK, qw(StreamingRequirement_to_string);
614 push @{$EXPORT_TAGS{"StreamingRequirement"}}, qw(StreamingRequirement_to_string);
616 my %_StreamingRequirement_VALUES;
617 #Convert an enum value to a single string
618 sub StreamingRequirement_to_string {
621 for my $k (keys %_StreamingRequirement_VALUES) {
622 my $v = $_StreamingRequirement_VALUES{$k};
624 #is this a matching flag?
625 if ($enumval == $v) {
630 #default, just return the number
634 push @EXPORT_OK, qw($STREAMING_REQUIREMENT_NONE);
635 push @{$EXPORT_TAGS{"StreamingRequirement"}}, qw($STREAMING_REQUIREMENT_NONE);
637 $_StreamingRequirement_VALUES{"NONE"} = $STREAMING_REQUIREMENT_NONE;
639 push @EXPORT_OK, qw($STREAMING_REQUIREMENT_DESIRED);
640 push @{$EXPORT_TAGS{"StreamingRequirement"}}, qw($STREAMING_REQUIREMENT_DESIRED);
642 $_StreamingRequirement_VALUES{"DESIRED"} = $STREAMING_REQUIREMENT_DESIRED;
644 push @EXPORT_OK, qw($STREAMING_REQUIREMENT_REQUIRED);
645 push @{$EXPORT_TAGS{"StreamingRequirement"}}, qw($STREAMING_REQUIREMENT_REQUIRED);
647 $_StreamingRequirement_VALUES{"REQUIRED"} = $STREAMING_REQUIREMENT_REQUIRED;
649 #copy symbols in StreamingRequirement to constants
650 push @{$EXPORT_TAGS{"constants"}}, @{$EXPORT_TAGS{"StreamingRequirement"}};
652 push @EXPORT_OK, qw(MediaAccessMode_to_string);
653 push @{$EXPORT_TAGS{"MediaAccessMode"}}, qw(MediaAccessMode_to_string);
655 my %_MediaAccessMode_VALUES;
656 #Convert an enum value to a single string
657 sub MediaAccessMode_to_string {
660 for my $k (keys %_MediaAccessMode_VALUES) {
661 my $v = $_MediaAccessMode_VALUES{$k};
663 #is this a matching flag?
664 if ($enumval == $v) {
669 #default, just return the number
673 push @EXPORT_OK, qw($MEDIA_ACCESS_MODE_READ_ONLY);
674 push @{$EXPORT_TAGS{"MediaAccessMode"}}, qw($MEDIA_ACCESS_MODE_READ_ONLY);
676 $_MediaAccessMode_VALUES{"READ_ONLY"} = $MEDIA_ACCESS_MODE_READ_ONLY;
678 push @EXPORT_OK, qw($MEDIA_ACCESS_MODE_WORM);
679 push @{$EXPORT_TAGS{"MediaAccessMode"}}, qw($MEDIA_ACCESS_MODE_WORM);
681 $_MediaAccessMode_VALUES{"WORM"} = $MEDIA_ACCESS_MODE_WORM;
683 push @EXPORT_OK, qw($MEDIA_ACCESS_MODE_READ_WRITE);
684 push @{$EXPORT_TAGS{"MediaAccessMode"}}, qw($MEDIA_ACCESS_MODE_READ_WRITE);
686 $_MediaAccessMode_VALUES{"READ_WRITE"} = $MEDIA_ACCESS_MODE_READ_WRITE;
688 push @EXPORT_OK, qw($MEDIA_ACCESS_MODE_WRITE_ONLY);
689 push @{$EXPORT_TAGS{"MediaAccessMode"}}, qw($MEDIA_ACCESS_MODE_WRITE_ONLY);
691 $_MediaAccessMode_VALUES{"WRITE_ONLY"} = $MEDIA_ACCESS_MODE_WRITE_ONLY;
693 #copy symbols in MediaAccessMode to constants
694 push @{$EXPORT_TAGS{"constants"}}, @{$EXPORT_TAGS{"MediaAccessMode"}};
696 push @EXPORT_OK, qw(SizeAccuracy_to_string);
697 push @{$EXPORT_TAGS{"SizeAccuracy"}}, qw(SizeAccuracy_to_string);
699 my %_SizeAccuracy_VALUES;
700 #Convert an enum value to a single string
701 sub SizeAccuracy_to_string {
704 for my $k (keys %_SizeAccuracy_VALUES) {
705 my $v = $_SizeAccuracy_VALUES{$k};
707 #is this a matching flag?
708 if ($enumval == $v) {
713 #default, just return the number
717 push @EXPORT_OK, qw($SIZE_ACCURACY_UNKNOWN);
718 push @{$EXPORT_TAGS{"SizeAccuracy"}}, qw($SIZE_ACCURACY_UNKNOWN);
720 $_SizeAccuracy_VALUES{"UNKNOWN"} = $SIZE_ACCURACY_UNKNOWN;
722 push @EXPORT_OK, qw($SIZE_ACCURACY_ESTIMATE);
723 push @{$EXPORT_TAGS{"SizeAccuracy"}}, qw($SIZE_ACCURACY_ESTIMATE);
725 $_SizeAccuracy_VALUES{"ESTIMATE"} = $SIZE_ACCURACY_ESTIMATE;
727 push @EXPORT_OK, qw($SIZE_ACCURACY_REAL);
728 push @{$EXPORT_TAGS{"SizeAccuracy"}}, qw($SIZE_ACCURACY_REAL);
730 $_SizeAccuracy_VALUES{"REAL"} = $SIZE_ACCURACY_REAL;
732 #copy symbols in SizeAccuracy to constants
733 push @{$EXPORT_TAGS{"constants"}}, @{$EXPORT_TAGS{"SizeAccuracy"}};
735 push @EXPORT_OK, qw(FeatureSupportFlags_to_strings);
736 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw(FeatureSupportFlags_to_strings);
738 my %_FeatureSupportFlags_VALUES;
739 #Convert a flag value to a list of names for flags that are set.
740 sub FeatureSupportFlags_to_strings {
744 for my $k (keys %_FeatureSupportFlags_VALUES) {
745 my $v = $_FeatureSupportFlags_VALUES{$k};
747 #is this a matching flag?
748 if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
753 #by default, just return the number as a 1-element list
761 push @EXPORT_OK, qw($FEATURE_STATUS_ENABLED);
762 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_STATUS_ENABLED);
764 $_FeatureSupportFlags_VALUES{"STATUS_ENABLED"} = $FEATURE_STATUS_ENABLED;
766 push @EXPORT_OK, qw($FEATURE_STATUS_DISABLED);
767 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_STATUS_DISABLED);
769 $_FeatureSupportFlags_VALUES{"STATUS_DISABLED"} = $FEATURE_STATUS_DISABLED;
771 push @EXPORT_OK, qw($FEATURE_SURETY_BAD);
772 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SURETY_BAD);
774 $_FeatureSupportFlags_VALUES{"SURETY_BAD"} = $FEATURE_SURETY_BAD;
776 push @EXPORT_OK, qw($FEATURE_SURETY_GOOD);
777 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SURETY_GOOD);
779 $_FeatureSupportFlags_VALUES{"SURETY_GOOD"} = $FEATURE_SURETY_GOOD;
781 push @EXPORT_OK, qw($FEATURE_SOURCE_DEFAULT);
782 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SOURCE_DEFAULT);
784 $_FeatureSupportFlags_VALUES{"SOURCE_DEFAULT"} = $FEATURE_SOURCE_DEFAULT;
786 push @EXPORT_OK, qw($FEATURE_SOURCE_DETECTED);
787 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SOURCE_DETECTED);
789 $_FeatureSupportFlags_VALUES{"SOURCE_DETECTED"} = $FEATURE_SOURCE_DETECTED;
791 push @EXPORT_OK, qw($FEATURE_SOURCE_USER);
792 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SOURCE_USER);
794 $_FeatureSupportFlags_VALUES{"SOURCE_USER"} = $FEATURE_SOURCE_USER;
796 push @EXPORT_OK, qw($FEATURE_SUPPORT_FLAGS_MAX);
797 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SUPPORT_FLAGS_MAX);
799 push @EXPORT_OK, qw($FEATURE_SUPPORT_FLAGS_MASK);
800 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SUPPORT_FLAGS_MASK);
802 push @EXPORT_OK, qw($FEATURE_SUPPORT_FLAGS_STATUS_MASK);
803 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SUPPORT_FLAGS_STATUS_MASK);
805 push @EXPORT_OK, qw($FEATURE_SUPPORT_FLAGS_SURETY_MASK);
806 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SUPPORT_FLAGS_SURETY_MASK);
808 push @EXPORT_OK, qw($FEATURE_SUPPORT_FLAGS_SOURCE_MASK);
809 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw($FEATURE_SUPPORT_FLAGS_SOURCE_MASK);
811 push @EXPORT_OK, qw(feature_support_flags_is_valid);
812 push @{$EXPORT_TAGS{"FeatureSupportFlags"}}, qw(feature_support_flags_is_valid);
814 #copy symbols in FeatureSupportFlags to constants
815 push @{$EXPORT_TAGS{"constants"}}, @{$EXPORT_TAGS{"FeatureSupportFlags"}};
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.
824 Amanda::Device::Device->new(@_);