void NexusGroup::WriteGroup (NXhandle file_handle, long int compression_scheme)
{
NexusGroup *current_group;
NexusField *current_field;
try
{
MakeGroup (name, type, file_handle);
OpenGroup (name, type, file_handle);
current_field = field_list;
while (current_field != NULL)
{
current_field->WriteField (file_handle, compression_scheme);
current_field = current_field->NextField ();
}
current_group = subgroup_list;
while (current_group != NULL)
{
current_group->WriteGroup (file_handle, compression_scheme);
current_group = current_group->NextGroup ();
}
CloseGroup (file_handle);
}
catch (...)
{
throw;
}
}
bool
ADIOSFileObject::ReadVariable(const std::string &nm,
int ts,
vtkDataArray **array)
{
debug5<<"ADIOSFileObject::ReadVariable("<<nm<<" time= "<<ts<<")"<<endl;
Open();
varIter vi = variables.find(nm);
if (vi == variables.end())
{
debug5<<"Variable "<<nm<<" not found."<<endl;
return false;
}
ADIOSVar v = vi->second;
int tupleSz = adios_type_size(v.type, NULL);
*array = ADIOSFileObject::AllocateArray(v.type);
int ntuples = 1;
uint64_t start[4] = {0,0,0,0}, count[4] = {0,0,0,0};
v.GetReadArrays(ts, start, count, &ntuples);
(*array)->SetNumberOfTuples(ntuples);
void *data = (*array)->GetVoidPointer(0);
debug5<<"ARR: adios_read_var:"<<endl<<v<<endl;
OpenGroup(v.groupIdx);
uint64_t retval = adios_read_var_byid(gps[v.groupIdx], v.varid, start, count, data);
CloseGroup(v.groupIdx);
return (retval > 0);
}
void
ADIOSFileObject::GetTimes(std::string &varNm, std::vector<double> ×)
{
Open();
times.resize(0);
varIter vi = variables.find(varNm);
if (vi == variables.end())
{
debug5<<"Variable "<<varNm<<" not found."<<endl;
return;
}
ADIOSVar v = vi->second;
int tupleSz = adios_type_size(v.type, NULL);
uint64_t start[4] = {0,0,0,0}, count[4] = {0,0,0,0};
count[0] = v.count[0];
int ntuples = v.count[0];
void *readData = malloc(ntuples*tupleSz);
OpenGroup(v.groupIdx);
uint64_t retval = adios_read_var_byid(gps[v.groupIdx], v.varid, start, count, readData);
CloseGroup(v.groupIdx);
if (retval > 0)
{
times.resize(ntuples);
ConvertTo(×[0], ntuples, v.type, readData);
}
free(readData);
}
//-*****************************************************************************
OrData::OrData( ObjectHeaderPtr iHeader,
H5Node & iParentGroup,
int32_t iArchiveVersion )
: m_children( NULL )
{
ABCA_ASSERT( iHeader, "Invalid header" );
ABCA_ASSERT( iParentGroup.isValidObject(), "Invalid group" );
m_group = OpenGroup( iParentGroup, iHeader->getName().c_str() );
ABCA_ASSERT( m_group.isValidObject(),
"Could not open object group: "
<< iHeader->getFullName() );
std::vector<std::string> objNames;
herr_t status = H5Literate( m_group.getObject(),
H5_INDEX_CRT_ORDER,
H5_ITER_INC,
NULL,
VisitAllLinksCB,
( void * )&objNames );
ABCA_ASSERT( status >= 0,
"OrData::OrData: H5Literate failed" );
std::vector < std::string >::iterator namesIt;
uint32_t i = 0;
if ( !objNames.empty() )
{
m_children = new Child[ objNames.size() ];
}
std::string parentFullName = iHeader->getFullName();
if ( parentFullName != "/" )
{
parentFullName += "/";
}
for ( namesIt = objNames.begin(); namesIt != objNames.end();
++namesIt, ++i )
{
m_childrenMap[ *namesIt ] = i;
m_children[i].header.reset( new AbcA::ObjectHeader( *namesIt,
parentFullName + *namesIt, AbcA::MetaData() ) );
m_children[i].loadedMetaData = false;
}
m_oldGroup = m_group;
m_data = Alembic::Util::shared_ptr<CprData>(
new CprData( m_group, iArchiveVersion, ".prop" ) );
}
static Err Login(ClientManager* _clientManager)
{
char password[MAX_NAME_SIZE],group[MAX_NAME_SIZE],fullName[64],msg[MAX_SIZE_OF_MESSAGE],ip[MAX_NAME_SIZE],port[MAX_NAME_SIZE];
char* ptr = NULL;
unsigned short numOfGroups;
e_tag tag;
int i;
if (! _clientManager)
{
return ERROR_NOT_INITIALIZED;
}
printf("please enter your name\n");
GetString(_clientManager->m_name);
printf("please enter password\n");
GetString(password);
AddTwoStrings(_clientManager->m_name,password,fullName);
SendToServer(_clientManager,fullName,TAG_LOGIN);
RecieveFromServer(_clientManager,&tag,&numOfGroups,msg);
if (tag == TAG_DENY)
{
printf("i'm sorry, you were denied access because: %s\n",msg);
return ERROR_LOGIN_FAILED;
}
else if (tag == TAG_LOGIN)
{
printf("you haven't enlisted to any groups\n");
return ERROR_OK;
}
else
{
numOfGroups /= (3*MAX_NAME_SIZE);
ptr = msg;
DEBUG_PRINT("%s %s","these are the groups you are in\n",_clientManager->m_name);
for (i = 0 ; i < numOfGroups ; i++)
{
strcpy(ip,ptr);
DEBUG_PRINT("%s %s","address : ",ptr);
ptr += MAX_NAME_SIZE;
strcpy(port,ptr);
DEBUG_PRINT("%s %s","port num :",ptr);
ptr += MAX_NAME_SIZE;
strcpy(group,ptr);
DEBUG_PRINT("%s %s","group name",ptr);
ptr += MAX_NAME_SIZE;
OpenGroup(_clientManager,ip,port,group);
}
}
return ERROR_OK;
}
bool
ADIOSFileObject::ReadVariable(const std::string &nm,
int ts,
vtkFloatArray **array)
{
debug5<<"ADIOSFileObject::ReadVariable("<<nm<<" time= "<<ts<<")"<<endl;
Open();
varIter vi = variables.find(nm);
if (vi == variables.end())
{
debug5<<"Variable "<<nm<<" not found."<<endl;
return false;
}
ADIOSVar v = vi->second;
int tupleSz = adios_type_size(v.type, NULL);
*array = vtkFloatArray::New();
int ntuples = 1;
uint64_t start[4] = {0,0,0,0}, count[4] = {0,0,0,0};
v.GetReadArrays(ts, start, count, &ntuples);
(*array)->SetNumberOfTuples(ntuples);
float *data = (float *)(*array)->GetVoidPointer(0);
void *readData = (void *)data;
bool convertData = (v.type != adios_real);
if (convertData)
readData = malloc(ntuples*tupleSz);
debug5<<"ARR: adios_read_var:"<<endl<<v<<endl;
OpenGroup(v.groupIdx);
uint64_t retval = adios_read_var_byid(gps[v.groupIdx], v.varid, start, count, readData);
CloseGroup(v.groupIdx);
if (convertData)
{
if (retval > 0)
ConvertTo(data, ntuples, v.type, readData);
free(readData);
}
return (retval > 0);
}
void BeginGroup(GroupStatement* group)
{
const char* translation = group->GetGroupTranslation();
const char* name = group->GetGroupName();
const char* text = NULL;
if (translation != NULL) {
text = translation;
} else {
text = name;
}
if (IsUIGroup(group)) {
AddUIGroup(text, group->GetStatement());
} else {
OpenGroup(text);
}
}
void GroupPropertiesView::AddGroupMembers(ColumnListView* listView)
{
DIR *groupList;
struct dirent *member;
groupList = OpenGroup(group);
if (groupList)
{
while ((member = ReadGroupMember(groupList)) != NULL)
{
char desc[64];
getUserFullName(member->d_name, desc, sizeof(desc));
listView->AddItem(new MemberItem(this, member->d_name, desc, ""));
}
CloseGroup(groupList);
}
}
//-*****************************************************************************
const AbcA::ObjectHeader &
OrData::getChildHeader( AbcA::ObjectReaderPtr iParent, size_t i )
{
ABCA_ASSERT( i < m_children.size(),
"Out of range index in OrData::getChildHeader: " << i );
Alembic::Util::scoped_lock l( m_childObjectsMutex );
if ( ! m_children[i].loadedMetaData )
{
H5Node group = OpenGroup( m_group,
m_children[i].header->getName().c_str() );
;
ABCA_ASSERT( group.isValidObject(),
"Could not open object group: "
<< m_children[i].header->getFullName() );
ReadMetaData( group, ".prop.meta",
m_children[i].header->getMetaData() );
CloseObject( group );
}
return *( m_children[i].header );
}
bool
ADIOSFileObject::ReadCoordinates(const std::string &nm,
int ts,
vtkPoints **pts)
{
Open();
varIter vi = variables.find(nm);
if (vi == variables.end())
{
debug5<<"Variable "<<nm<<" not found."<<endl;
return false;
}
ADIOSVar v = vi->second;
*pts = ADIOSFileObject::AllocatePoints(v.type);
int ntuples = 1;
uint64_t start[4] = {0,0,0,0}, count[4] = {0,0,0,0};
v.GetReadArrays(ts, start, count, &ntuples);
ntuples /= v.dim;
(*pts)->SetNumberOfPoints(ntuples);
void *data = (*pts)->GetVoidPointer(0), *data2 = NULL;
void *readData = data;
if (v.dim < 3)
{
if (v.type == adios_real)
data2 = malloc(ntuples*3*sizeof(float));
else if (v.type == adios_double)
data2 = malloc(ntuples*3*sizeof(double));
else if (v.type == adios_integer)
data2 = malloc(ntuples*3*sizeof(int));
readData = data2;
}
OpenGroup(v.groupIdx);
debug5<<"adios_read_var:"<<endl<<v<<endl;
uint64_t retval = adios_read_var_byid(gps[v.groupIdx], v.varid, start, count, readData);
if (retval > 0)
{
if (readData != data)
{
int i, j, n = ntuples*3;
for (i=0, j=0; i < n; i += 3, j += v.dim)
{
int k;
for (k = 0; k < v.dim; k++)
((double *)data)[i+k] = ((double *)data2)[j+k];
for ( ; k < 3; k++)
((double *)data)[i+k] = 0.0;
}
free(data2);
}
}
CloseGroup(v.groupIdx);
return (retval > 0);
}
//-*****************************************************************************
CprData::CprData( H5Node & iParentGroup, int32_t iArchiveVersion,
const std::string &iName )
: m_subPropertyMutexes( NULL )
{
ABCA_ASSERT( iParentGroup.isValidObject(), "invalid parent group" );
// If our group exists, open it. If it does not, this is not a problem!
// It just means we don't have any subproperties.
if ( !GroupExists( iParentGroup, iName ) )
{
// No group. It's okay!
// Just return - it means we have no subprops!
return;
}
m_group = OpenGroup( iParentGroup, iName.c_str() );
ABCA_ASSERT( m_group.isValidObject(),
"Could not open compound property group named: "
<< iName << ", H5Gopen2 failed" );
// Do the visiting to gather property names.
CprAttrVisitor visitor;
HDF5Hierarchy* h5HPtr = iParentGroup.getH5HPtr();
if ( h5HPtr )
{
h5HPtr->visitAllAttributes( iParentGroup.getRef(), iName, visitor );
}
else
{
try
{
herr_t status = H5Aiterate2( m_group.getObject(),
H5_INDEX_CRT_ORDER,
H5_ITER_INC,
NULL,
CprVisitAllAttrsCB,
( void * )&visitor );
ABCA_ASSERT( status >= 0,
"CprData::CprData(): H5Aiterate failed" );
}
catch ( std::exception & exc )
{
ABCA_THROW( "Could not attr iterate property group named: "
<< iName << ", reason: " << exc.what() );
}
catch ( ... )
{
ABCA_THROW( "Could not attr iterate property group named: "
<< iName << ", unknown reason" );
}
}
size_t index = 0;
m_propertyHeaders.resize( visitor.properties.size() );
m_subPropertyMutexes =
new Alembic::Util::mutex[ visitor.properties.size() ];
// For each property name, read the various pieces of information
for ( std::vector<std::string>::iterator siter = visitor.properties.begin();
siter != visitor.properties.end(); ++siter, ++index )
{
m_subProperties[(*siter)] = index;
m_propertyHeaders[index].name = (*siter);
m_propertyHeaders[index].numSamples = 0;
m_propertyHeaders[index].firstChangedIndex = 0;
m_propertyHeaders[index].lastChangedIndex = 0;
m_propertyHeaders[index].isScalarLike = false;
}
}
//-*****************************************************************************
ArImpl::ArImpl( const std::string &iFileName,
AbcA::ReadArraySampleCachePtr iCache,
const bool iCacheHierarchy )
: m_fileName( iFileName )
, m_file( -1 )
, m_readArraySampleCache( iCache )
{
// OPEN THE FILE!
htri_t exi = H5Fis_hdf5( m_fileName.c_str() );
ABCA_ASSERT( exi == 1, "Nonexistent or not an Alembic file: "
<< m_fileName );
m_file = H5Fopen( m_fileName.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT );
ABCA_ASSERT( m_file >= 0,
"Could not open file: " << m_fileName );
// get the version using HDF5 native calls
int version = -INT_MAX;
if (H5Aexists(m_file, "abc_version"))
{
size_t numRead = 0;
ReadSmallArray(m_file, "abc_version", H5T_STD_I32LE, H5T_NATIVE_INT32,
1, numRead, &version);
}
ABCA_ASSERT(version >= -8 && version <= ALEMBIC_HDF5_FILE_VERSION,
"Unsupported file version detected: " << version);
// if it isn't there, it's pre 1.0
int fileVersion = 9999;
if (H5Aexists( m_file, "abc_release_version" ))
{
size_t numRead = 0;
ReadSmallArray( m_file, "abc_release_version", H5T_STD_I32LE,
H5T_NATIVE_INT32, 1, numRead, &fileVersion );
}
m_archiveVersion = fileVersion;
HDF5HierarchyReader reader( m_file, m_H5H, iCacheHierarchy );
H5Node node = m_H5H.createNode( m_file );
H5Node abcRoot = OpenGroup( node, "ABC" );
AbcA::MetaData metaData;
ReadMetaData( abcRoot, ".prop.meta", metaData );
m_header.reset( new AbcA::ObjectHeader( "ABC", "/", metaData ) );
m_data.reset( new OrData( m_header, node, m_archiveVersion ) );
CloseObject( abcRoot );
ReadTimeSamples( m_file, m_timeSamples );
if ( H5Aexists( m_file, "abc_max_samples" ) )
{
hid_t aid = H5Aopen( m_file, "abc_max_samples", H5P_DEFAULT );
if ( aid < 0 )
{
return;
}
AttrCloser attrCloser( aid );
// figure out how big it is
hid_t sid = H5Aget_space( aid );
if ( sid < 0 )
{
return;
}
DspaceCloser dspaceCloser( sid );
hssize_t numPoints = H5Sget_simple_extent_npoints( sid );
if ( numPoints < 1 )
{
return;
}
m_maxSamples.resize( numPoints );
// do the read
H5Aread( aid, H5T_NATIVE_LLONG, &( m_maxSamples.front() ) );
}
}
static Err Menu(ClientManager* _clientManager)
{
int option;
char group[MAX_NAME_SIZE],ip[MAX_NAME_SIZE],port[MAX_NAME_SIZE];
char message[MAX_SIZE_OF_MESSAGE];
unsigned short length;
Data data;
char* ptr = NULL;
if (! _clientManager)
{
return ERROR_NOT_INITIALIZED;
}
printf("welcome %s!!!\nplease choose one of the following options:\n1. open group\n2. join group\n3. leave group\n4. get all groups\n5. get members of group\n6. log out\n7. unregister\n8. printf groups im in\n9. quit\n",_clientManager->m_name);
select(FD_SETSIZE, &_clientManager->m_fd, NULL, NULL, NULL);
if (FD_ISSET(0, &_clientManager->m_fd) == 1)
{
scanf("%d",&option);
getchar();
switch(option)
{
case 1:
DEBUG_PRINT("%s","going to open group");
printf("please enter the group name you wish to create\n");
if (ERROR_OK == ExecuteCommands(_clientManager,TAG_OPEN_GROUP,group,message,&length))
{
ptr = message;
strcpy(ip,ptr);
ptr += MAX_NAME_SIZE;
strcpy(port,ptr);
OpenGroup(_clientManager,ip,port,group);
return ERROR_OK;
}
return ERROR_END_MAIN;
case 2:
DEBUG_PRINT("%s","going to join group");
printf("please enter the group name you wish to join\n");
if (ERROR_OK == ExecuteCommands(_clientManager,TAG_JOIN_GROUP,group,message,&length))
{
ptr = message;
strcpy(ip,ptr);
ptr += MAX_NAME_SIZE;
strcpy(port,ptr);
OpenGroup(_clientManager,ip,port,group);
return ERROR_OK;
}
return ERROR_OK;
case 3:
DEBUG_PRINT("%s","going to leave group");
if (ERROR_OK == ExecuteCommands(_clientManager,TAG_LEAVE_GROUP,group,message,&length))
{
HashRemove(_clientManager->m_groups,group,&data);
return ERROR_OK;
}
return ERROR_OK;
case 4:
DEBUG_PRINT("%s","going to get all groups");
if (ERROR_OK == ExecuteCommands(_clientManager,TAG_GET_GROUPS,NULL,message,&length))
{
PrintData(length,message);
return ERROR_OK;
}
return ERROR_OK;
case 5:
DEBUG_PRINT("%s","going to get members of group");
printf("please enter the name of the group you wish to see members from\n");
if (ERROR_OK == ExecuteCommands(_clientManager,TAG_GET_MEMBERS,group,message,&length))
{
PrintData(length,message);
return ERROR_OK;
}
return ERROR_OK;
case 6:
DEBUG_PRINT("%s","going to log out");
if (ERROR_OK == ExecuteCommands(_clientManager,TAG_LOGOUT,NULL,message,&length))
{
LogOut(_clientManager);
return ERROR_END_MENU;
}
case 7:
if (ERROR_OK == ExecuteCommands(_clientManager,TAG_UNREGISTER,group,message,&length))
{
printf("unregistered succsesfully\n");
return ERROR_END_MENU;
}
return ERROR_OK;
case 8:
HashPrint(_clientManager->m_groups,PrintGroupsImIn);
return ERROR_OK;
case 9:
return ERROR_END_MAIN;
default:
printf("i'm sorry, no such option, please try again\n");
return ERROR_OK;
}
}
else if (FD_ISSET(_clientManager->m_socket, &_clientManager->m_fd) == 1)
{}
return ERROR_OK;
}
