void _applyOpToDataFiles( const string& database, FileOp &fo, bool afterAllocator, const string& path ) { if ( afterAllocator ) FileAllocator::get()->waitUntilFinished(); string c = database; c += '.'; boost::filesystem::path p(path); if (storageGlobalParams.directoryperdb) p /= database; boost::filesystem::path q; q = p / (c+"ns"); bool ok = false; MONGO_ASSERT_ON_EXCEPTION( ok = fo.apply( q ) ); if ( ok ) { LOG(2) << fo.op() << " file " << q.string() << endl; } int i = 0; int extra = 10; // should not be necessary, this is defensive in case there are missing files while ( 1 ) { verify( i <= DiskLoc::MaxFiles ); stringstream ss; ss << c << i; q = p / ss.str(); MONGO_ASSERT_ON_EXCEPTION( ok = fo.apply(q) ); if ( ok ) { if ( extra != 10 ) { LOG(1) << fo.op() << " file " << q.string() << endl; log() << " _applyOpToDataFiles() warning: extra == " << extra << endl; } } else if ( --extra <= 0 ) break; i++; } }
// this function is shared by chmod/utime/chown maybe others // it's here for directories which may span multiple backends // returns PLFS_SUCCESS or PLFS_E* static plfs_error_t plfs_flatfile_operation(struct plfs_physpathinfo *ppip, FileOp& op, IOStore *ios) { plfs_error_t ret = PLFS_SUCCESS; vector<plfs_pathback> dirs; struct stat st; mode_t mode = 0; ret = ppip->canback->store->Lstat(ppip->canbpath.c_str(), &st); if (ret != PLFS_SUCCESS){ mode = 0; } else { mode = st.st_mode; } //perform operation on ALL directories if (S_ISDIR(mode)){ ret = generate_backpaths(ppip, dirs); vector<plfs_pathback>::reverse_iterator ritr; for(ritr = dirs.rbegin(); ritr != dirs.rend() && ret == PLFS_SUCCESS; ++ritr) { ret = op.op(ritr->bpath.c_str(),DT_DIR,ritr->back->store); } } //we hit a regular flat file else if(S_ISREG(mode)){ ret = op.op(ppip->canbpath.c_str(), DT_REG, ios); } //symlink else if (S_ISLNK(mode)){ ret = op.op(ppip->canbpath.c_str(), DT_LNK, ios); } return(ret); }
int main() { // Start Object FileOp test = FileOp("test", "test"); test.run("C:\\Users\\super_000\\Code\\ClassDev\\ProgLang\\Python\\initial_file.txt"); // Exit Program system("PAUSE"); return 0; }
// Disabled this function as it is currently not used. // If we decide to use, we should check on the usage of fileop.getFileName(). // With iteration 17, the more common version of this getFileName() takes a // partition and segment number in addition to an OID. openColumnFile // should perhaps be changed to use this updated version of getFileName(). bool DDLIndexPopulator::openColumnFile(WriteEngine::OID oid) { FileOp fileOp; char fileName[WriteEngine::FILE_NAME_SIZE]; if (WriteEngine::NO_ERROR == fileOp.getFileName(oid, fileName) ) { fColumnFile.open(fileName); return true; } else { logError("Could not get column file name for data"); return false; } }
/** * plfs_backends_op: apply a fileop to all the backends in a mount. * currently used by readdir, rmdir, mkdir * this doesn't require the dires to already exist * * @param ppip the phyiscal path we are operating on * @param op the file op to apply * @return PLFS_SUCCESS or PLFS_E* */ plfs_error_t plfs_backends_op(struct plfs_physpathinfo *ppip, FileOp& op) { plfs_error_t ret = PLFS_SUCCESS; vector<plfs_pathback> exps; vector<plfs_pathback>::iterator itr; if ( (ret = generate_backpaths(ppip, exps)) != PLFS_SUCCESS ) { return(ret); } for(itr = exps.begin(); itr != exps.end() && ret == PLFS_SUCCESS; itr++ ) { ret = op.op(itr->bpath.c_str(),DT_DIR,itr->back->store); mlog(INT_DCOMMON, "%s on %s: %d",op.name(),itr->bpath.c_str(),ret); } return(ret); }
Palette* load_palette(const char *filename) { std::string ext = base::string_to_lower(base::get_file_extension(filename)); Palette* pal = NULL; if (ext == "col") { pal = doc::file::load_col_file(filename); } else if (ext == "gpl") { pal = doc::file::load_gpl_file(filename); } else { FileFormat* ff = FileFormatsManager::instance()->getFileFormatByExtension(ext.c_str()); if (ff->support(FILE_SUPPORT_LOAD)) { FileOp* fop = fop_to_load_document(NULL, filename, FILE_LOAD_SEQUENCE_NONE | FILE_LOAD_ONE_FRAME); if (fop && !fop->has_error()) { fop_operate(fop, NULL); fop_post_load(fop); if (fop->document && fop->document->sprite() && fop->document->sprite()->getPalette(FrameNumber(0))) { pal = new Palette( *fop->document->sprite()->getPalette(FrameNumber(0))); // TODO remove this line when support for palettes with less // than 256 colors is added. pal->resize(Palette::MaxColors); } delete fop->document; fop_done(fop); } } } if (pal) pal->setFilename(filename); return pal; }
int main(int argc, char **argv) { if(argc != MAX_PARAMETERS) { std::cout << "Invalid number of arguments \n"; return FAILURE; } else { if(argv[1] == INVALID_FIE_NAME) { std::cout << "Invalid file name \n"; return FAILURE; } /*Read equations from file and store each equation*/ FileOp *fp = new FileOp(argv[1]); if(fp) { fp->getEqFromFile(); int eqCount = (int)(fp->getEqCount()); Parser *pp = new Parser(); while(eqCount--) { int retVal; std::string eq = fp->getNextEq(); /*Parse the equation and validate*/ retVal = pp->parseEq(eq); } /*evaluate the equations and store the value*/ pp->evalEq(); /*Print the sorted out put of the list of variables used*/ pp->printValues(); delete pp; delete fp; } } return SUCCESS; }
// this function is shared by chmod/utime/chown maybe others // it's here for directories which may span multiple backends // returns 0 or -err int plfs_flatfile_operation(const char *logical, FileOp& op, IOStore *ios) { FLAT_ENTER; vector<plfs_pathback> dirs; mode_t mode = 0; ret = is_plfs_file(logical, &mode); //perform operation on ALL directories if (S_ISDIR(mode)){ ret = find_all_expansions(logical, dirs); vector<plfs_pathback>::reverse_iterator ritr; for(ritr = dirs.rbegin(); ritr != dirs.rend() && ret == 0; ++ritr) { ret = op.op(ritr->bpath.c_str(),DT_DIR,ritr->back->store); } } //we hit a regular flat file else if(S_ISREG(mode)){ ret = op.op(path.c_str(), DT_REG, ios); } //symlink else{ ret = op.op(path.c_str(), DT_LNK, ios); } FLAT_EXIT(ret); }
void NDMapData::decode(FILE* pkStream) { FileOp kFileOp; //<-------------------地图名 m_strName = kFileOp.readUTF8String(pkStream);//[self readUTF8String:stream]; CCLog(m_strName.c_str()); //<-------------------单元格尺寸 int nUnitSize_DontUseIt = kFileOp.readByte(pkStream); //not used. // int nTileWidth = m_nUnitSize; // int nTileHeight = m_nUnitSize; //@del int nTileWidth = MAP_UNITSIZE_X; int nTileHeight = MAP_UNITSIZE_Y; //------------------->层数 m_nLayerCount = kFileOp.readByte(pkStream); //<-------------------列数 m_nColumns = kFileOp.readByte(pkStream); //------------------->行数 m_nRows = kFileOp.readByte(pkStream); //<-------------------使用到的图块资源 std::vector < std::string > kTileImages; int nTileImageCount = kFileOp.readShort(pkStream); for (int i = 0; i < nTileImageCount; i++) { int nIDx = kFileOp.readShort(pkStream); char pszImageName[256] = { 0 }; sprintf(pszImageName, "%st%d.png", NDEngine::NDPath::GetImagePath().c_str(), nIDx); FILE* pkFile = fopen(pszImageName, "rb"); if (pkFile) { kTileImages.push_back(pszImageName); } else { return; } } //------------------->瓦片 m_kMapTiles = CCArray::array(); m_kMapTiles->retain(); for (int lay = 0; lay < m_nLayerCount; lay++) { for (unsigned int r = 0; r < m_nRows; r++) { for (unsigned int c = 0; c < m_nColumns; c++) { int nImageIndex = kFileOp.readByte(pkStream) - 1; //资源下标 if (nImageIndex == -1) { nImageIndex = 0; } int nTileIndex = kFileOp.readByte(pkStream); //图块下标 bool reverse = kFileOp.readByte(pkStream) == 1; //翻转 if (nImageIndex == -1) { nImageIndex = 0; } if (kTileImages.size() > nImageIndex) { std::string strImageName = kTileImages[nImageIndex]; NDTile* pkTile = new NDTile; pkTile->setTexture( NDPicturePool::DefaultPool()->AddTexture( strImageName.c_str())); int nPicParts = pkTile->getTexture()->getPixelsWide() * pkTile->getTexture()->getMaxS() / nTileWidth; pkTile->setCutRect( CCRectMake(nTileWidth * (nTileIndex % nPicParts), nTileHeight * (nTileIndex / nPicParts), nTileWidth, nTileHeight)); pkTile->setDrawRect( CCRectMake(nTileWidth * c, nTileHeight * r, nTileWidth, nTileHeight)); pkTile->setReverse(reverse); m_kMapTiles->addObject(pkTile); pkTile->release(); } } } } //<-------------------通行 m_pkObstacles = new std::vector<bool>(); for (unsigned int i = 0; i < m_nColumns * m_nRows; i++) { m_pkObstacles->push_back(true); } int nNotPassCount = kFileOp.readShort(pkStream); for (int i = 0; i < nNotPassCount; i++) { int nRowIndex = kFileOp.readByte(pkStream); int nColumnIndex = kFileOp.readByte(pkStream); int nIndex = nRowIndex * m_nColumns + nColumnIndex; if (m_pkObstacles->size() > nIndex) { (*m_pkObstacles)[nIndex] = false; } } //------------------->切屏 m_pkSwitchs = CCArray::array(); m_pkSwitchs->retain(); int nSwitchsCount = kFileOp.readByte(pkStream); for (int i = 0; i < nSwitchsCount; i++) { kFileOp.readByte(pkStream); //切屏点x kFileOp.readByte(pkStream); //切屏点y kFileOp.readByte(pkStream); //目标地图 kFileOp.readByte(pkStream); //目标点 } //<---------------------使用到的背景资源 std::vector < std::string > kBackGroundImages; std::vector<int> _bgOrders; int bgImageCount = (kFileOp.readByte(pkStream) << 8) + kFileOp.readByte(pkStream); for (int i = 0; i < bgImageCount; i++) { int idx = kFileOp.readShort(pkStream); char imageName[256] = { 0 }; sprintf(imageName, "%sb%d.png", NDEngine::NDPath::GetImagePath().c_str(), idx); FILE* pkFile = fopen(imageName, "rb"); if (pkFile) { kBackGroundImages.push_back(imageName); } else { kBackGroundImages.push_back(imageName); } int v = kFileOp.readShort(pkStream); _bgOrders.push_back(v); } //---------------------->背景 m_pkBackgroundTiles = CCArray::array(); m_pkBackgroundTiles->retain(); int bgCount = (kFileOp.readByte(pkStream) << 8) + kFileOp.readByte(pkStream); for (int i = 0; i < bgCount; i++) { int nResourceIndex = kFileOp.readByte(pkStream); //资源下标 int nX = kFileOp.readShort(pkStream); //x坐标 int nY = kFileOp.readShort(pkStream); //y坐标 bool nReverse = kFileOp.readByte(pkStream) > 0; //翻转 if (kBackGroundImages.size() <= nResourceIndex || _bgOrders.size() <= nResourceIndex) { continue; } std::string strImageName = kBackGroundImages[nResourceIndex]; NDSceneTile* pkTile = new NDSceneTile; pkTile->setOrderID(_bgOrders[nResourceIndex] + nY); pkTile->setTexture( CCTextureCache::sharedTextureCache()->addImage( strImageName.c_str())); int picWidth = pkTile->getTexture()->getPixelsWide() * pkTile->getTexture()->getMaxS(); int picHeight = pkTile->getTexture()->getPixelsHigh() * pkTile->getTexture()->getMaxT(); pkTile->setMapSize( CCSizeMake(m_nColumns * nTileWidth, m_nRows * nTileHeight)); pkTile->SetCutRect_Android( CCRectMake(0, 0, picWidth, picHeight), getBattleMapFlag() || getDramaMapFlag()); //@android pkTile->SetDrawRect_Android(CCRectMake(nX, nY, picWidth, picHeight), getBattleMapFlag() || getDramaMapFlag()); //@android pkTile->setReverse(nReverse); pkTile->make(); m_pkBackgroundTiles->addObject(pkTile); pkTile->release(); } //<-------------------使用到的布景资源 std::vector < std::string > kSceneImages; std::vector<int> kSceneOrders; int nSceneImageCount = (kFileOp.readByte(pkStream) << 8) + kFileOp.readByte(pkStream); for (int i = 0; i < nSceneImageCount; i++) { int nIDx = kFileOp.readShort(pkStream); char szImageName[256] = { 0 }; sprintf(szImageName, "%ss%d.png", NDEngine::NDPath::GetImagePath().c_str(), nIDx); FILE* pkFile = fopen(szImageName, "rb"); if (pkFile) { kSceneImages.push_back(szImageName); } else { //NDLog("布景资源%@没有找到!!!", imageName); kSceneImages.push_back(szImageName); } int v = static_cast<short>(kFileOp.readShort(pkStream)); kSceneOrders.push_back(v); } //------------------->布景 m_pkSceneTiles = CCArray::array(); m_pkSceneTiles->retain(); int nSceneCount = kFileOp.readShort(pkStream); for (int i = 0; i < nSceneCount; i++) { int nResourceIndex = kFileOp.readByte(pkStream); //资源下标 int x = (short) ((kFileOp.readByte(pkStream) << 8) + kFileOp.readByte(pkStream)); //x坐标 int y = (short) ((kFileOp.readByte(pkStream) << 8) + kFileOp.readByte(pkStream)); //y坐标 BOOL bReverse = kFileOp.readByte(pkStream) > 0; //翻转 if (kSceneImages.size() <= nResourceIndex || kSceneOrders.size() <= nResourceIndex) { continue; } NDSceneTile* pkTile = new NDSceneTile; pkTile->setOrderID(kSceneOrders[nResourceIndex] + y); std::string strImagePath = kSceneImages[nResourceIndex]; pkTile->setTexture( CCTextureCache::sharedTextureCache()->addImage( strImagePath.c_str())); int nPicWidth = pkTile->getTexture()->getPixelsWide() * pkTile->getTexture()->getMaxS(); int nPicHeight = pkTile->getTexture()->getPixelsHigh() * pkTile->getTexture()->getMaxT(); pkTile->setMapSize( CCSizeMake(m_nColumns * nTileWidth, m_nRows * nTileHeight)); pkTile->SetCutRect_Android( CCRectMake(0, 0, nPicWidth, nPicHeight), getBattleMapFlag() || getDramaMapFlag()); //@android pkTile->SetDrawRect_Android( CCRectMake(x, y, nPicWidth, nPicHeight), getBattleMapFlag() || getDramaMapFlag()); //@android pkTile->setReverse(bReverse); pkTile->make(); m_pkSceneTiles->addObject(pkTile); pkTile->release(); } //<-------------------动画 m_pkAnimationGroups = CCArray::array(); m_pkAnimationGroups->retain(); m_pkAniGroupParams = CCArray::array(); m_pkAniGroupParams->retain(); int m_AniGroupCount = kFileOp.readShort(pkStream); for (int i = 0; i < m_AniGroupCount; i++) { int nIdentifer = kFileOp.readShort(pkStream); //动画id NDAnimationGroup *pkAniGroup = NDAnimationGroupPool::defaultPool()->addObjectWithSceneAnimationId( nIdentifer); if (!pkAniGroup) { continue; } m_pkAnimationGroups->addObject(pkAniGroup); pkAniGroup->release(); int x = kFileOp.readShort(pkStream); //x坐标 int y = kFileOp.readShort(pkStream); //y坐标 int nAniOrder = y + kFileOp.readShort(pkStream); //排序重心 anigroup_param* pkDict = new anigroup_param; pkDict->insert(std::make_pair("reverse", 0)); pkDict->insert(std::make_pair("positionX", x)); pkDict->insert(std::make_pair("positionY", y)); pkDict->insert(std::make_pair("mapSizeW", m_nColumns * MAP_UNITSIZE_X)); pkDict->insert(std::make_pair("mapSizeH", m_nRows * MAP_UNITSIZE_Y)); pkDict->insert(std::make_pair("orderId", nAniOrder)); pkDict->insert(std::make_pair("reverse", 0)); pkDict->insert(std::make_pair("reverse", 0)); m_pkAniGroupParams->addObject(pkDict); pkDict->release(); } //------------------->刷怪区 // NSMutableArray *_monsterRanges = [[NSMutableArray alloc] init]; // int monsterRangeCount = [stream readByte]; // for (int i = 0; i < monsterRangeCount; i++) // { // NDMapMonsterRange *monsterRange = [[NDMapMonsterRange alloc] init]; // // monsterRange.typeId = [stream readInt]; // monsterRange.column = [stream readByte]; // monsterRange.row = [stream readByte]; // monsterRange.boss = [stream readByte] != 0; // // [_monsterRanges addObject:monsterRange]; // [monsterRange release]; // } // // [_tileImages release]; // [_sceneImages release]; // [_sceneOrders release]; // [_monsterRanges release]; // [_bgImages release]; // [_bgOrders release]; }
/** * plfs_file_operation: this function is shared by * chmod/utime/chown/etc. anything that needs to operate on possibly * a lot of items either on a bunch of dirs across the backends or on * a bunch of entries within a container Be careful. This performs a * stat. Do not use for performance critical operations. If needed, * then you'll have to figure out how to cheaply pass the mode_t in * * @param ppip the phyiscal path we are working with * @param op the FileOp operation we are going to perform * @return PLFS_SUCCESS or PLFS_E* */ static plfs_error_t plfs_file_operation(struct plfs_physpathinfo *ppip, FileOp& op) { plfs_error_t ret = PLFS_SUCCESS; vector<plfs_pathback> files, dirs, links; string accessfile; struct plfs_pathback pb; // first go through and find the set of physical files and dirs // that need to be operated on // if it's a PLFS file, then maybe we just operate on // the access file, or maybe on all subentries // if it's a directory, then we operate on all backend copies // else just operate on whatever it is (ENOENT, symlink) mode_t mode = 0; ret = (is_container_file(ppip,&mode) == false) ? PLFS_SUCCESS : PLFS_TBD; bool is_container = false; // differentiate btwn logical dir and container if (S_ISREG(mode)) { // it's a PLFS file if (op.onlyAccessFile()) { pb.bpath = Container::getAccessFilePath(ppip->canbpath); pb.back = ppip->canback; files.push_back(pb); ret = PLFS_SUCCESS; // ret was one from is_container_file } else { // everything is_container = true; accessfile = Container::getAccessFilePath(ppip->canbpath); ret = plfs_collect_from_containers(ppip,files,dirs,links); } } else if (S_ISDIR(mode)) { // need to iterate across dirs ret = generate_backpaths(ppip, dirs); } else { // ENOENT, a symlink, somehow a flat file in here pb.bpath = ppip->canbpath; pb.back = ppip->canback; files.push_back(pb); // we might want to reset ret to 0 here } // now apply the operation to each operand so long as ret==0. dirs must be // done in reverse order and files must be done first. This is necessary // for when op is unlink since children must be unlinked first. for the // other ops, order doesn't matter. vector<plfs_pathback>::reverse_iterator ritr; for(ritr = files.rbegin(); ritr != files.rend() && ret == PLFS_SUCCESS; ++ritr) { // In container mode, we want to special treat accessfile deletion, // because once accessfile deleted, the top directory will no longer // be viewed as a container. Defer accessfile deletion until last moment // so that if anything fails in the middle, the container information // remains. if (is_container && accessfile == ritr->bpath) { mlog(INT_DCOMMON, "%s skipping accessfile %s", __FUNCTION__, ritr->bpath.c_str()); continue; } mlog(INT_DCOMMON, "%s on %s",__FUNCTION__,ritr->bpath.c_str()); ret = op.op(ritr->bpath.c_str(),DT_REG,ritr->back->store); } for(ritr = links.rbegin(); ritr != links.rend() && ret == PLFS_SUCCESS; ++ritr) { op.op(ritr->bpath.c_str(),DT_LNK,ritr->back->store); } for(ritr = dirs.rbegin(); ritr != dirs.rend() && ret == PLFS_SUCCESS; ++ritr) { if (is_container && ritr->bpath == ppip->canbpath) { mlog(INT_DCOMMON, "%s skipping canonical top directory%s", __FUNCTION__, ppip->canbpath.c_str()); continue; } ret = op.op(ritr->bpath.c_str(), is_container?(unsigned char)DT_CONTAINER:(unsigned char)DT_DIR, ritr->back->store); } if (is_container) { mlog(INT_DCOMMON, "%s processing access file and canonical top dir", __FUNCTION__); ret = op.op(accessfile.c_str(), DT_REG, ppip->canback->store); if (ret == PLFS_SUCCESS) ret = op.op(ppip->canbpath.c_str(), DT_CONTAINER, ppip->canback->store); } mlog(INT_DAPI, "%s: ret %d", __FUNCTION__,ret); return(ret); }