DatafieldRef.h

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* @package    ArmarX::Core
* @author     Kai Welke (welke@kit.edu)
* @date       2011 Kai Welke
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include <type_traits>
 
#include <ArmarXCore/core/system/ImportExport.h>
#include <ArmarXCore/interface/observers/DataFieldIdentifierBase.h>
#include <ArmarXCore/interface/observers/ObserverInterface.h>
#include <ArmarXCore/observers/exceptions/local/InvalidDataFieldException.h>
#include <ArmarXCore/observers/variant/ChannelRef.h>
#include <ArmarXCore/observers/variant/DataFieldIdentifier.h>
#include <ArmarXCore/observers/variant/TimedVariant.h>
 
namespace armarx
{
 
 
    class DatafieldRef;
    using DatafieldRefPtr = IceInternal::Handle<DatafieldRef>;
 
    /**
     * @class DatafieldRef
     * @ingroup VariantsGrp
     * @brief The DatafieldRef class is similar to the \ref ChannelRef, but points
     * to a specific Datafield instead of to a complete channel.
     * It can be used to query (@ref getDataField()) the data of the datafield from the \ref Observer.
     */
    class ARMARXCORE_IMPORT_EXPORT DatafieldRef : virtual public DatafieldRefBase
    {
        template <class BaseClass, class VariantClass>
        friend class GenericFactory;
 
    protected:
        DatafieldRef();
 
    public:
        DatafieldRef(Observer* observer,
                     const std::string& channelName,
                     const std::string& datafieldName,
                     bool performValidation = true);
 
        DatafieldRef(ObserverInterfacePrx observerPrx,
                     const std::string& channelName,
                     const std::string& datafieldName,
                     bool performValidation = true);
        DatafieldRef(ChannelRefPtr channelRef,
                     const std::string& datafieldName,
                     bool performValidation = true);
 
        ~DatafieldRef() override
        {
        }
 
        // inherited from VariantDataClass
        Ice::ObjectPtr ice_clone() const override;
 
        VariantDataClassPtr clone(const Ice::Current& c = Ice::emptyCurrent) const override;
        std::string output(const Ice::Current& c = Ice::emptyCurrent) const override;
        VariantTypeId getType(const Ice::Current& c = Ice::emptyCurrent) const override;
        bool validate(const Ice::Current& c = Ice::emptyCurrent) override;
 
 
        // datafield access
        DataFieldIdentifierPtr getDataFieldIdentifier() const;
 
        /**
         * @brief Retrieves the value of the datafield from the \ref Observer.
         * @return Variant with the type and value of the datafield.
         */
        TimedVariantPtr getDataField() const;
 
        // helper methods for variant content access
        template <typename T>
        typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>, IceInternal::Handle<T>>
        get() const
        {
            VariantPtr var = getDataField();
 
            if (!var)
            {
                throw armarx::exceptions::local::InvalidDataFieldException(channelRef->channelName,
                                                                           datafieldName);
            }
 
            return var->get<T>();
        }
 
        template <typename T>
        typename std::enable_if_t<!std::is_base_of_v<VariantDataClass, T>, T>
        get() const
        {
            VariantPtr var = getDataField();
 
            if (!var)
            {
                throw armarx::exceptions::local::InvalidDataFieldException(channelRef->channelName,
                                                                           datafieldName);
            }
 
            return var->get<T>();
        }
 
        bool
        getBool(const Ice::Current& c = Ice::emptyCurrent) const override
        {
            return get<bool>();
        }
 
        int
        getInt(const Ice::Current& c = Ice::emptyCurrent) const override
        {
            return get<int>();
        }
 
        long
        getLong(const Ice::Current& c = Ice::emptyCurrent) const override
        {
            return get<long>();
        }
 
        float
        getFloat(const Ice::Current& c = Ice::emptyCurrent) const override
        {
            return get<float>();
        }
 
        double
        getDouble(const Ice::Current& c = Ice::emptyCurrent) const override
        {
            return get<double>();
        }
 
        std::string
        getString(const Ice::Current& c = Ice::emptyCurrent) const override
        {
            return get<std::string>();
        }
 
        ChannelRefPtr getChannelRef() const;
 
        /**
        * stream operator for DataFieldIdentifier
        */
        friend std::ostream&
        operator<<(std::ostream& stream, const DatafieldRef& rhs)
        {
            stream << rhs.output();
            return stream;
        }
 
        /**
        * stream operator for Ice shared pointer of DataFieldIdentifier
        */
        friend std::ostream&
        operator<<(std::ostream& stream, const DatafieldRefPtr& rhs)
        {
            stream << rhs->output();
            return stream;
        }
 
    public: // serialization
        void serialize(const ObjectSerializerBasePtr& serializer,
                       const ::Ice::Current& = Ice::emptyCurrent) const override;
        void deserialize(const ObjectSerializerBasePtr& serializer,
                         const ::Ice::Current& = Ice::emptyCurrent) override;
 
    private:
        mutable DataFieldIdentifierPtr id;
    };
} // namespace armarx
 
namespace armarx::VariantType
{
    const VariantTypeId DatafieldRef = Variant::addTypeName("::armarx::DatafieldRefBase");
}
 
 
extern template class ::IceInternal::Handle<::armarx::DatafieldRef>;