gridfs.h

Go to the documentation of this file.

 
/*    Copyright 2009 10gen Inc.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
 
#pragma once
 
#include "boost/scoped_array.hpp"
 
#include "mongo/bson/bsonelement.h"
#include "mongo/bson/bsonobj.h"
#include "mongo/client/dbclientinterface.h"
#include "mongo/client/export_macros.h"
 
namespace mongo {
 
    typedef unsigned long long gridfs_offset;
 
    class GridFS;
    class GridFile;
    class GridFileBuilder;
 
    class MONGO_CLIENT_API GridFSChunk {
    public:
        GridFSChunk( BSONObj data );
        GridFSChunk( BSONObj fileId , int chunkNumber , const char * data , int len );
 
        int len() const {
            int len;
            _data["data"].binDataClean( len );
            return len;
        }
 
        const char * data( int & len ) const {
            return _data["data"].binDataClean( len );
        }
 
    private:
        BSONObj _data;
        friend class GridFS;
    };
 
 
    class MONGO_CLIENT_API GridFS {
    public:
        GridFS( DBClientBase& client , const std::string& dbName , const std::string& prefix="fs" );
        ~GridFS();
 
        void setChunkSize(unsigned int size);
 
        unsigned int getChunkSize() const;
 
        BSONObj storeFile( const std::string& fileName , const std::string& remoteName="" , const std::string& contentType="");
 
        BSONObj storeFile( const char* data , size_t length , const std::string& remoteName , const std::string& contentType="");
 
        void removeFile( const std::string& fileName );
 
        GridFile findFile( Query query ) const;
 
        GridFile findFileByName( const std::string& fileName ) const;
 
        std::auto_ptr<DBClientCursor> list() const;
 
        std::auto_ptr<DBClientCursor> list( BSONObj query ) const;
 
    private:
        DBClientBase& _client;
        std::string _dbName;
        std::string _prefix;
        std::string _filesNS;
        std::string _chunksNS;
        unsigned int _chunkSize;
 
        // insert fileobject. All chunks must be in DB.
        BSONObj insertFile(const std::string& name, const OID& id, gridfs_offset length, const std::string& contentType);
 
        // Insert a chunk into DB, this method is intended to be used by
        // GridFileBuilder to incrementally insert chunks
        void _insertChunk(const GridFSChunk& chunk);
 
        friend class GridFile;
        friend class GridFileBuilder;
    };
 
    class MONGO_CLIENT_API GridFile {
    public:
        bool exists() const {
            return ! _obj.isEmpty();
        }
 
        std::string getFilename() const {
            return _obj["filename"].str();
        }
 
        int getChunkSize() const {
            return (int)(_obj["chunkSize"].number());
        }
 
        gridfs_offset getContentLength() const {
            return (gridfs_offset)(_obj["length"].number());
        }
 
        std::string getContentType() const {
            return _obj["contentType"].valuestr();
        }
 
        Date_t getUploadDate() const {
            return _obj["uploadDate"].date();
        }
 
        std::string getMD5() const {
            return _obj["md5"].str();
        }
 
        BSONElement getFileField( const std::string& name ) const {
            return _obj[name];
        }
 
        BSONObj getMetadata() const;
 
        int getNumChunks() const {
            return (int) ceil( (double)getContentLength() / (double)getChunkSize() );
        }
 
        GridFSChunk getChunk( int n ) const;
 
        gridfs_offset write( std::ostream & out ) const;
 
        gridfs_offset write( const std::string& where ) const;
 
    private:
        GridFile(const GridFS * grid , BSONObj obj );
 
        void _exists() const;
 
        const GridFS * _grid;
        BSONObj        _obj;
 
        friend class GridFS;
    };
    
    class GridFileBuilder {
    public:
        GridFileBuilder( GridFS* const grid );
        
        void appendChunk( const char* data, size_t length );
 
        mongo::BSONObj buildFile( const std::string& remoteName,
                                  const std::string& contentType="" );
        
    private:
        GridFS* const _grid;
        const size_t _chunkSize; // taken from GridFS in the constructor
        unsigned int _currentChunk;
        OID _fileId;
        BSONObj _fileIdObj;
        boost::scoped_array<char> _pendingData; // pointer with _chunkSize space
        size_t _pendingDataSize;
        gridfs_offset _fileLength;
 
        const char* _appendChunk( const char* data, size_t length,
                                  bool forcePendingInsert );
 
        void _appendPendingData();
    };
 
 
}