NamedField.hpp

#ifndef FISH_BONE_NAMEDFIELD_HPP
#define FISH_BONE_NAMEDFIELD_HPP
 
#include <bone/GridOperatorObject.hpp>
#include <bone/FishField.hpp>
#include <bone/FieldObject.hpp>
#include <shrimp/VObjectStatus.hpp>
 
namespace Fiber
{
 
#if     0
 
template <size_t N>
struct  ConstString
{
        char    buf[N + 1];
 
        constexpr ConstString(const ConstString&CS)
        {
                for (size_t i = 0; i != N; ++i)
                        buf[i] = CS.buf[i];
        }
 
        constexpr ConstString(char const* s)
        {
                for (size_t i = 0; i != N; ++i)
                        buf[i] = s[i];
        }
 
        std::string str() const
        {
                return std::string(buf,N);
        }
};
 
template<unsigned N>
ConstString(char const (&)[N]) -> ConstString<N - 1>;
 
#else
 
using ConstString = const char*;
 
static inline string mystr(ConstString s)
{
        return string(s);
}
 
#endif
 
template <ConstString FieldName>
struct  NamedField : public GridOperatorObject<VObject>
                   , public StatusIndicator
{
        VOutput<Fiber::Field>   theField;
 
        VOutput<string>         theFieldName;
 
 
        NamedField(const string&name, int p, const RefPtr<VCreationPreferences>&VP)
        : GridOperatorObject<VObject>(name, p, VP)
        , StatusIndicator(this)
        , theField(this, "field", {} )
        , theFieldName(this, "fieldname", FieldName )
        {}
 
        ~NamedField()
        {}
 
static  bool    hasDesiredField(const RefPtr<Skeleton>&theSkeleton)
        {
        bool    SadResult = true;
                if (!theSkeleton) return SadResult;
 
                theSkeleton->iterate_fields( [&SadResult]
                        (const Representer&theRepresenter, const Representation&R,
                         const FieldID&theFieldID, const Field&theField)
                {
                        if (theFieldID.Name() == FieldName)
                        {
                                SadResult = false;
                                return false;
                        }
                        return true;
                }
                );
 
                return not SadResult;
        }
 
        bool    update(VRequest&Context, double precision) override
        {
        Fiber::Bundle::GridInfo_t
                iG = findMostRecentGrid(Context);
 
        RefPtr<Grid> G = iG;
                if (!G)
                {
                FieldSelector FS;
                        theField << Context << FS;
                        return setStatusError(Context, "No Grid.");
                }
 
        RefPtr<Skeleton> theSkeleton = G->findVertices();
                if (!theSkeleton)
                {
                FieldSelector FS;
                        theField << Context << FS;
                        return setStatusError(Context, "No Vertices on this Grid.");
                }
 
                if (!hasDesiredField(theSkeleton) )
                {
                        return setStatusError(Context, "No such field on this Grid.");
                }
 
        FieldSelector FS( getGridSelector( Context ), iG);
                FS.selectField( FieldName );
                FS.mySkeletonID = *theSkeleton;
                theField << Context << FS;
 
                return setStatusInfo(Context, "Field [" + mystr(FieldName) + "] found on this Grid.");
        }
 
 
static  bool    HasFields(const WeakPtr<VCreatorBase>&VB, const RefPtr<VObject>&vobj, const Fiber::TypeList_t&AcceptedFields)
        {
                if (!vobj) return false;
 
                struct  : VOutputIterator
                {
                        bool    HappyResult = false;
 
                        bool    apply(const type_info&Type, const RefPtr<VSlot>&slot) override
                        {
                        GridSelector GS;
                                if (slot->getValue( GS, NullPtr() ) )
                                {
                                Info<Skeleton> iS = GS.getRefinementLevel(0.0, 0,0);
 
                                        HappyResult = hasDesiredField(iS.getSkeleton());
 
                                        return false;
                                }
 
                                return true;
                        }
                }       VOut;
 
                vobj->iterateOutputs(VOut, typeid(GridSelector) );
 
                return VOut.HappyResult ;
        }
};
 
 
} // namespace Fiber
 
#endif // FISH_BONE_NAMEDFIELD_HPP