Sample.h

Go to the documentation of this file.

#ifndef __KOME_OBJECTS_SAMPLE_H__
#define __KOME_OBJECTS_SAMPLE_H__


#include <string>
#include <vector>
#include "DataSet.h"


namespace kome {
    namespace objects {

        class SampleSet;
        class DataGroupNode;
        class Spectrum;     
        class Chromatogram; 
        class Peaks;

        class DATA_OBJECTS_CLASS Sample {
        public:
             Sample( SampleSet* sampleSet );

            virtual ~Sample();

        protected:
            SampleSet* m_sampleSet;

            int m_sampleIdx;

            int m_specId;

            std::string m_name;

            std::string m_type;

            std::string m_instrument;

            std::string m_company;

            std::string m_softwareName;

            std::string m_softwareVersion;

            DataGroupNode* m_root;

            bool m_opened;

            bool m_edited;

            std::vector< DataGroupNode* > m_groups;

            bool m_parallelReadable;
            
            DataSet m_hiddenSet;

            bool m_supportedApiPeaks;

            static int m_optSampleId;

        protected:
            static std::vector< std::string > m_commonProps;

        public:
            SampleSet* getSampleSet();

            void setSampleIndex( const int index );

            int getSampleIndex();

            void setName( const char* name );

            const char* getName();

            void setType( const char* type );

            const char* getType();

            void setInstrument( const char* instrument );

            const char* getInstrument();

            void setMsCompany( const char* company );

            const char* getMsCompany();

            void setSoftwareName( const char* name );

            const char* getSoftwareName();

            void setSoftwareVersion( const char* version );

            const char* getSoftwareVersion();

            void setOpened( const bool opened );

            bool isOpened();

            void setEdited( const bool edited );

            bool isEdited();

            DataGroupNode* getRootDataGroupNode();

            DataSet* getHiddenDataSet();

            unsigned int getNumberOfGroups();

            DataGroupNode* getGroup( const unsigned int index );

            void setParallelReadable( const bool readable );

            bool isParallelReadable();

            static void resetId();

        protected:
            void getGroups( DataGroupNode* parentGroup = NULL );

        public:
            bool openSample( kome::core::Progress* progress = NULL );

            bool closeSample();

            void detectPeaksByAPI( Spectrum* spec, Peaks* peaks );

        public:
            static bool isCommonProperty( const char* key );
        
        public:
            static int issueSampleId();

            void setSampleId( int id );
            
            int getSampleId();

            static Sample* getSampleById( int id );
            
            int issueSpecId();

            Spectrum* getSpectrumById( int id );
            
            int issueChromId( Sample* sample );

            Chromatogram* getChromatogramById( int id );
            
            int issueGroupId( Sample* sample );

            DataGroupNode* getGroupById( int id );

        public:
            bool isSupportedAPIPeaks();

            void setSupportedAPIPeaks( const bool supported );

        protected:
            virtual void onDetectPeaksByAPI( Spectrum* spec, Peaks* peaks );

        protected:
            virtual bool onOpenSample( DataGroupNode* rootGroup, kome::core::Progress* progress ) = 0;

            virtual bool onCloseSample() = 0;
        };
    }
}


#endif      // __KOME_OBJECTS_SAMPLE_H__