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; }