dataheaders.hpp

gps源代码

        {
            source.type = st;
            source.sourceName = sourcename;
        };

        /// Explicit constructor
        sourceTypeHeader(const SourceID& sI, const TypeID& datatype) : type(datatype) { source = sI; };

        /// Explicit constructor from parent class
        sourceTypeHeader(const sourceHeader& sh, const TypeID& datatype) : sourceHeader(sh), type(datatype) {};

        /// Copy constructor
        sourceTypeHeader(const sourceTypeHeader& sth) : type(sth.type) { source = sth.source; };

        /// Assignment operator from a sourceTypeHeader
        virtual sourceTypeHeader& operator=(const sourceTypeHeader& right)
        {
            if ( this == &right ) return (*this);
            (*this).source = right.source;
            (*this).type = right.type;
            return *this;
        }

        /// Assignment operator from a sourceHeader
        virtual sourceTypeHeader& operator=(const sourceHeader& right)
        {
            (*this).source = right.source;
            return *this;
        }

        /// Assignment operator from a SourceID
        virtual sourceTypeHeader& operator=(const SourceID& right)
        {
            (*this).source = right;
            return *this;
        }

        /// Convenience output method for sourceTypeHeader
        virtual std::ostream& dump(std::ostream& s) const;

        /// Destructor
        virtual ~sourceTypeHeader() {};

    };


    /// stream output for sourceTypeHeader
    std::ostream& operator<<(std::ostream& s, const sourceTypeHeader& sth);




    /// Defines a header containing the source and satellite ID of data
    struct sourceSatHeader : public sourceHeader 
    {
        /// Field holding the satellite ID this data belongs to
        SatID satellite;

        /// Default constructor
        sourceSatHeader() {};

        /// Explicit constructor
        sourceSatHeader(const SourceID::SourceType& st, const std::string& sourcename, const SatID& sat) : satellite(sat)
        {
            source.type = st;
            source.sourceName = sourcename;
        };

        /// Explicit constructor
        sourceSatHeader(const SourceID& sI, const SatID& sat) : satellite(sat) { source = sI; };

        /// Explicit constructor from parent class
        sourceSatHeader(const sourceHeader& sh, const SatID& sat) : sourceHeader(sh), satellite(sat) {};

        /// Copy constructor
        sourceSatHeader(const sourceSatHeader& ssh) : satellite(ssh.satellite) { source = ssh.source; };

        /// Assignment operator from a sourceSatHeader
        virtual sourceSatHeader& operator=(const sourceSatHeader& right)
        {
            if ( this == &right ) return (*this);
            (*this).source = right.source;
            (*this).satellite = right.satellite;
            return *this;
        }

        /// Assignment operator from a sourceHeader
        virtual sourceSatHeader& operator=(const sourceHeader& right)
        {
            (*this).source = right.source;
            return *this;
        }

        /// Assignment operator from a SourceID
        virtual sourceSatHeader& operator=(const SourceID& right)
        {
            (*this).source = right;
            return *this;
        }

        /// Convenience output method for sourceSatHeader
        virtual std::ostream& dump(std::ostream& s) const;

        /// Destructor
        virtual ~sourceSatHeader() {};

    };


    /// stream output for sourceSatHeader
    std::ostream& operator<<(std::ostream& s, const sourceSatHeader& ssh);




    /// Defines a header containing the source, satellite ID and epoch of data
    struct sourceEpochSatHeader : public sourceEpochHeader 
    {
        /// Field holding the satellite ID this data belongs to
        SatID satellite;

        /// Default constructor
        sourceEpochSatHeader() {};

        /// Explicit constructor
        sourceEpochSatHeader(const SourceID::SourceType& st, const std::string& sourcename, const DayTime& time, const SatID& sat) : satellite(sat)
        {
            source.type = st;
            source.sourceName = sourcename;
            epoch = time;
        };

        /// Explicit constructor
        sourceEpochSatHeader(const SourceID& sI, const DayTime& time, const SatID& sat) : satellite(sat) { source = sI; epoch = time; };

        /// Explicit constructor
        sourceEpochSatHeader(const sourceHeader& sh, const DayTime& time, const SatID& sat) : satellite(sat) { source = sh.source; epoch = time; };

        /// Explicit constructor from parent class
        sourceEpochSatHeader(const sourceEpochHeader& seh, const SatID& sat) : satellite(sat) { source = seh.source; epoch = seh.epoch; };

        /// Copy constructor
        sourceEpochSatHeader(const sourceEpochSatHeader& sesh) : satellite(sesh.satellite) { source = sesh.source; epoch = sesh.epoch; };

        /// Assignment operator from a sourceEpochSatHeader
        virtual sourceEpochSatHeader& operator=(const sourceEpochSatHeader& right)
        {
            if ( this == &right ) return (*this);
            (*this).source = right.source;
            (*this).epoch = right.epoch;
            (*this).satellite = right.satellite;
            return *this;
        }

        /// Assignment operator from a sourceEpochHeader
        virtual sourceEpochSatHeader& operator=(const sourceEpochHeader& right)
        {
            (*this).source = right.source;
            (*this).epoch = right.epoch;
            return *this;
        }

        /// Assignment operator from a sourceHeader
        virtual sourceEpochSatHeader& operator=(const sourceHeader& right)
        {
            (*this).source = right.source;
            return *this;
        }

        /// Assignment operator from a SourceID
        virtual sourceEpochSatHeader& operator=(const SourceID& right)
        {
            (*this).source = right;
            return *this;
        }

        /// Convenience output method for sourceEpochSatHeader
        virtual std::ostream& dump(std::ostream& s) const;

        /// Destructor
        virtual ~sourceEpochSatHeader() {};

    };


    /// stream output for sourceEpochSatHeader
    std::ostream& operator<<(std::ostream& s, const sourceEpochSatHeader& sesh);




    /// Defines a header containing the source, type and epoch of data
    struct sourceEpochTypeHeader : public sourceEpochHeader 
    {
        /// Field describing the type of data being held
        TypeID type;

        /// Default constructor
        sourceEpochTypeHeader() {};

        /// Explicit constructor
        sourceEpochTypeHeader(const SourceID::SourceType& st, const std::string& sourcename, const DayTime& time, const TypeID& datatype) : type(datatype)
        {
            source.type = st;
            source.sourceName = sourcename;
            epoch = time;
        };

        /// Explicit constructor
        sourceEpochTypeHeader(const SourceID& sI, const DayTime& time, const TypeID& datatype) : type(datatype) { source = sI; epoch = time; };

        /// Explicit constructor
        sourceEpochTypeHeader(const sourceHeader& sh, const DayTime& time, const TypeID& datatype) : type(datatype) { source = sh.source; epoch = time; };

        /// Explicit constructor from parent class
        sourceEpochTypeHeader(const sourceEpochHeader& seh, const TypeID& datatype) : type(datatype) { source = seh.source; epoch = seh.epoch; };

        /// Copy constructor
        sourceEpochTypeHeader(const sourceEpochTypeHeader& sesh) : type(sesh.type) { source = sesh.source; epoch = sesh.epoch; };

        /// Assignment operator from a sourceEpochTypeHeader
        virtual sourceEpochTypeHeader& operator=(const sourceEpochTypeHeader& right)
        {
            if ( this == &right ) return (*this);
            (*this).source = right.source;
            (*this).epoch = right.epoch;
            (*this).type = right.type;
            return *this;
        }

        /// Assignment operator from a sourceEpochHeader
        virtual sourceEpochTypeHeader& operator=(const sourceEpochHeader& right)
        {
            (*this).source = right.source;
            (*this).epoch = right.epoch;
            return *this;
        }

        /// Assignment operator from a sourceHeader
        virtual sourceEpochTypeHeader& operator=(const sourceHeader& right)
        {
            (*this).source = right.source;
            return *this;
        }

        /// Assignment operator from a SourceID
        virtual sourceEpochTypeHeader& operator=(const SourceID& right)
        {
            (*this).source = right;
            return *this;
        }

        /// Convenience output method for sourceEpochTypeHeader
        virtual std::ostream& dump(std::ostream& s) const;

        /// Destructor
        virtual ~sourceEpochTypeHeader() {};

    };


    /// stream output for sourceEpochTypeHeader
    std::ostream& operator<<(std::ostream& s, const sourceEpochTypeHeader& seth);


   //@}

   
} // namespace gpstk
#endif