PDL::IO::HDF5::Group - PDL::IO::HDF5 Helper Object representing HDF5 groups.

   $a = new PDL::IO::HDF5:Group( name => $name, parent => $parent,
   			      fileObj => $fileObj );
	Args:
	$name				Name of the group (relative to the parent)
	$parent				Parent Object that owns this group
	$fileObj                        PDL::HDF (Top Level) object that owns this group.

   No Usage. Automatically called

   $group->attrSet( 'attr1' => 'attr1Value',
   		    'attr2' => 'attr2 value', 
                    'attr3' => $pdl,
		    .
		    .
		    .
		   );

   my @attrs = $group->attrGet( 'attr1', 'attr2');

   $group->attrDel( 'attr1', 
      		    'attr2',
		    .
		    .
		    .
		   );

   @attrs = $group->attrs;

   $dataset = $group->dataset('newdataset');

   @datasets = $group->datasets;

   $newgroup = $oldgroup->group("newgroup");

   @groupNames = $group->groups;

   $group->_buildAttrIndex($index, $currentAttrs);

    


 Input/Output:

         $index:        Total Index hash ref
	 $currentAttrs: Hash refs of the attributes valid 
	                for the current group.

 my $ID = $groupObj->IDget;

 my $name = $groupObj->nameGet;

package PDL::IO::HDF5::Group;


use Carp;

use strict;

sub new{

	my $type = shift;
	my %parms = @_;
	my $self = {};

	my @DataMembers = qw( name parent fileObj);
	my %DataMembers;
	@DataMembers{ @DataMembers } = @DataMembers; # hash for quick lookup
	# check for proper supplied names:
	my $varName;
	foreach $varName(keys %parms){
 		unless( defined($DataMembers{$varName})){
			carp("Error Calling ".__PACKAGE__." Constuctor\n  \'$varName\' not a valid data member\n"); 
			return undef;
		}
		$self->{$varName} = $parms{$varName};
	}
	
	my $parent = $self->{parent};
	my $parentID = $parent->IDget;
	my $parentName = $parent->nameGet;
	my $groupName = $self->{name};
	my $groupID;
	
	# Adjust groupname to be absolute:
	if( $parentName ne '/') {  # Parent is not the root group
		$self->{name} = "$parentName/$groupName";
	}
	else{  # Parent is root group
		$self->{name} = "$parentName$groupName";
	}

	

	# Turn Error Reporting off for the following, so H5 lib doesn't complain
	#  if the group isn't found.
	PDL::IO::HDF5::H5errorOff();
	my $rc = PDL::IO::HDF5::H5Gget_objinfo($parentID, $groupName,1,0);
	PDL::IO::HDF5::H5errorOn();
	# See if the group exists:
	if(  $rc >= 0){ 
		#Group Exists open it:
		$groupID = PDL::IO::HDF5::H5Gopen($parentID, $groupName);
	}
	else{  # group didn't exist, create it:
		$groupID = PDL::IO::HDF5::H5Gcreate($parentID, $groupName, 0);
		# Clear-out the attribute index, it is no longer valid with the updates
		#  we just made.
		$self->{fileObj}->clearAttrIndex;

	}
	# Try Opening the Group First (Assume it already exists)

	if($groupID < 0 ){
		carp "Error Calling ".__PACKAGE__." Constuctor: Can't open or create group '$groupName'\n";
		return undef;
	}
		
	
	$self->{ID} = $groupID;

	bless $self, $type;

	return $self;
}	

sub DESTROY {
  my $self = shift;
  #print "In Group DEstroy\n";
  if( PDL::IO::HDF5::H5Gclose($self->{ID}) < 0){
	warn("Error closing HDF5 Group '".$self->{name}."' in file '".$self->{parentName}."'\n");
  }

}

sub attrSet {
	my $self = shift;
	
	# Attribute setting for groups is exactly like datasets
	#  Call datasets directly (This breaks OO inheritance, but is 
	#   better than duplicating code from the dataset object here
	return $self->PDL::IO::HDF5::Dataset::attrSet(@_);

  
}

sub attrGet {
	my $self = shift;
	
	
	# Attribute reading for groups is exactly like datasets
	#  Call datasets directly (This breaks OO inheritance, but is 
	#   better than duplicating code from the dataset object here
	return $self->PDL::IO::HDF5::Dataset::attrGet(@_);


}

sub attrDel {
	my $self = shift;

	my @attrs = @_; # get atribute names
	
	my $groupID = $self->{ID};
	
	my $attr;
	my $rc; #Return code returned by H5Adelete
	foreach $attr( @attrs ){
		

		# Note: We don't consider errors here as cause for aborting, we just
		#  complain using carp
		if( PDL::IO::HDF5::H5Adelete($groupID, $attr) < 0){
			carp "Error in ".__PACKAGE__." attrDel; Error Deleting attribute '$attr'\n";
		}
		
	}
	# Clear-out the attribute index, it is no longer valid with the updates
	#  we just made.
	$self->{fileObj}->clearAttrIndex;
	
	return 1;
  
}

sub attrs {
	my $self = shift;

	my $groupID = $self->{ID};
	
	my $defaultMaxSize = 256; # default max size of a attribute name

	my $noAttr = PDL::IO::HDF5::H5Aget_num_attrs($groupID); # get the number of attributes

	my $attrIndex = 0; # attribute Index

	my @attrNames = ();
	my $attributeID;
	my $attrNameSize; # size of the attribute name
	my $attrName;     # attribute name

	# Go thru each attribute and get the name
	for( $attrIndex = 0; $attrIndex < $noAttr; $attrIndex++){

		$attributeID = PDL::IO::HDF5::H5Aopen_idx($groupID, $attrIndex );

		if( $attributeID < 0){
			carp "Error in ".__PACKAGE__." attrs; Error Opening attribute number $attrIndex\n";
			next;
		}

	      	#init attrname to 256 length string (Maybe this not necessary with
		#  the typemap)
		$attrName = ' ' x 256;
		
		# Get the name
		$attrNameSize = PDL::IO::HDF5::H5Aget_name($attributeID, 256, $attrName ); 

		# If the name is greater than 256, try again with the proper size:
		if( $attrNameSize > 256 ){
			$attrName = ' ' x $attrNameSize;
			$attrNameSize = PDL::IO::HDF5::H5Aget_name($attributeID, $attrNameSize, $attrName ); 

		}

		push @attrNames, $attrName;

		# Close the attr:
		PDL::IO::HDF5::H5Aclose($attributeID);
	}


	
	return @attrNames;
  
}

sub dataset {
	my $self = shift;

	my $name = $_[0];

	my $groupID = $self->{ID}; # get the group name of the current group
	
	my $dataset = PDL::IO::HDF5::Dataset->new( name=> $name, parent => $self,
					 fileObj => $self->{fileObj} );

}

sub datasets {
	my $self = shift;

	my $groupID = $self->{ID};
	
	my @totalDatasets = PDL::IO::HDF5::H5GgetDatasetNames($groupID,".");
	
		
	
	return @totalDatasets;
  
}

sub group {
	my $self = shift;

	my $name = $_[0]; # get the group name
	
	
	my $group =  new PDL::IO::HDF5::Group( name=> $name, parent => $self,
					fileObj => $self->{fileObj}  );
					

	return $group;

}

sub groups {
	my $self = shift;

	my $groupID = $self->{ID};
	
	my @totalgroups = PDL::IO::HDF5::H5GgetGroupNames($groupID,'.');
	
		
	
	return @totalgroups;
  
}

sub _buildAttrIndex{

	my ($self, $index, $currentAttrs) = @_;
	
	# Take care of any attributes in the current group
	my @attrs = $self->attrs;
	
	my @attrValues = $self->attrGet(@attrs);
	
	# Get the group name
	my $groupName = $self->nameGet;
	
	my %indexElement; # element of the index for this group
	
	%indexElement = %$currentAttrs; # Initialize index element
				        # with attributes valid at the 
					# group above
					
	# Add (or overwrite) attributes for this group
	#    i.e. local group attributes take precedence over
	#         higher-level attributes
	@indexElement{@attrs} = @attrValues;
	
	$index->{$groupName} = \%indexElement;
	
	 
	# Now Do any subgroups: 
	my @subGroups = $self->groups;
	my $subGroup;
	
	foreach $subGroup(@subGroups){
		$self->group($subGroup)->_buildAttrIndex($index,\%indexElement);
	}
	
}

sub IDget{

	my $self = shift;
	
	return $self->{ID};
		
}

sub nameGet{

	my $self = shift;
	
	return $self->{name};
		
}

1;