cl_Input_Section.hpp

Go to the documentation of this file.

/*
 * BELFEM -- The Berkeley Lab Finite Element Framework
 * Copyright (c) 2026, The Regents of the University of California,
 * through Lawrence Berkeley National Laboratory (subject to receipt of any required
 * approvals from the U.S. Dept. of Energy).  All rights reserved.
 *
 * Developers: Christian Messe, Gregory Giard
 *
 * See the top-level LICENSE file for the complete license and disclaimer.
 */
 
#ifndef BELFEM_CL_INPUT_SECTION_HPP
#define BELFEM_CL_INPUT_SECTION_HPP
 
#include "typedefs.hpp"
#include "stringtools.hpp"
#include "cl_Cell.hpp"
#include "cl_Map.hpp"
#include "cl_Vector.hpp"
 
namespace belfem
{
    namespace input
    {
 
//------------------------------------------------------------------------------
        class Section
        {
            const Section * mParent ;
            const int mLevel ;
            const Cell< string > & mBuffer ;
            const string mType ;
            const string mLabel ;
            const string mKey ;
            const index_t mStartFlag ;
            const index_t mEndFlag ;
            Cell < Section * > mData ;
 
 
            Map< string, Section * > mSections ;
            Map< string, string > mKeys ;
            Map< string, real >   mRealKeys ;
            Map< string, value >  mValueKeys ;
 
            Cell< string > mKeyLabels ;
 
//------------------------------------------------------------------------------
                public:
//------------------------------------------------------------------------------
 
            Section(
                    const Section        * aParent,
                    const Cell< string > & aBuffer,
                    const string         & aKey,
                    const index_t          aStartFlag,
                    const index_t          aEndFlag
                );
 
//------------------------------------------------------------------------------
 
            ~Section() ;
 
//------------------------------------------------------------------------------

            const string &
            type() const;
 
//------------------------------------------------------------------------------

            const string &
            label() const;
 
//------------------------------------------------------------------------------
 
            const string &
            key() const;
 
//------------------------------------------------------------------------------

             bool
             section_exists( const string & aType ) const;
 
//------------------------------------------------------------------------------

            bool
            section_exists( const string & aType, const string & aLabel ) const;
 
//------------------------------------------------------------------------------

            bool
            key_exists( const string & aKey ) const;
 
//------------------------------------------------------------------------------

            bool
            key_is_real( const string & aKey ) const;
 
//------------------------------------------------------------------------------

            const string &
            get_string( const string & aKey ) const;
 
//------------------------------------------------------------------------------

            bool
            get_bool( const string & aKey ) const;
 
//------------------------------------------------------------------------------

            real
            get_real( const string & aKey ) const;
 
//------------------------------------------------------------------------------

            value
            get_value( const string & aKey , const string & aUnit ) const;
 
//------------------------------------------------------------------------------

            void
            get_value( const index_t aIndex, string & aKey, value & aValue ) const ;
 
//------------------------------------------------------------------------------

            string
            get_units( const string & aKey ) const;
 
//------------------------------------------------------------------------------

            int
            get_int( const string & aKey ) const;
 
//------------------------------------------------------------------------------
 
            void
            get_ids( const string & aKey, Vector< id_t > & aIDs ) const ;
 
//------------------------------------------------------------------------------
 
            void
            get_intersection_list( const string & aKey, Vector< id_t > & aIDs1, Vector< id_t > & aIDs2 ) const ;
 
//------------------------------------------------------------------------------
 
            std::pair< id_t, id_t >
            get_intersection_ids( const string & aKey ) const ;
 
//------------------------------------------------------------------------------
 
            void
            get_ids( const string & aKey, const string & aTape, Vector< id_t > & aIDs ) const ;
 
//------------------------------------------------------------------------------
 
            void
            get_id_groups( const string & aKey, Cell<Cell< id_t >> & aIDs ) const ;
 
//------------------------------------------------------------------------------
 
            void
            get_reals( const string & aKey, Vector< real > & aReals ) const ;
 
//------------------------------------------------------------------------------

             const Section *
             section( const string & aType  ) const ;
 
//------------------------------------------------------------------------------

            const Section *
            section( const string & aType, const string & aLabel  ) const ;
 
//------------------------------------------------------------------------------

             const Section *
             section( const index_t aIndex ) const ;
 
//------------------------------------------------------------------------------

             index_t
             num_sections() const ;
 
//------------------------------------------------------------------------------

             index_t
             num_keys() const ;
 
//------------------------------------------------------------------------------

             const string &
             key( const index_t aIndex ) const ;
 
//------------------------------------------------------------------------------

             int
             level() const ;
 
//------------------------------------------------------------------------------

             const Section *
             parent() const ;
 
//------------------------------------------------------------------------------

             string
             tree() const ;
 
//------------------------------------------------------------------------------

             index_t
             start() const ;
 
//------------------------------------------------------------------------------

             index_t
             end() const ;
 
//------------------------------------------------------------------------------
 
            void
            ids_from_string( const string & aString, Vector< id_t > & aIDs  ) const ;
 
//------------------------------------------------------------------------------
 
            const Cell< string > &
            buffer() const ;
 
//------------------------------------------------------------------------------
        private:
//------------------------------------------------------------------------------
 
            void
            create_children();
 
//------------------------------------------------------------------------------
 
            void
            create_key( const string & aLine );
 
//------------------------------------------------------------------------------
 
            string
            error_section_not_exisits( const string & aSection ) const ;
 
//------------------------------------------------------------------------------
 
            string
            error_key_not_exists( const string & aKey ) const ;
 
//------------------------------------------------------------------------------
 
            string
            error_key_not_real( const string & aKey ) const ;
 
//------------------------------------------------------------------------------
 
            string
            get_type( const string & aLine ) const ;
 
            string
            get_label( const string & aLine ) const ;
 
//------------------------------------------------------------------------------
        };
 
 
 
//------------------------------------------------------------------------------
 
        inline index_t
        Section::num_sections() const
        {
            return mData.size() ;
        }
 
//------------------------------------------------------------------------------
 
        inline index_t
        Section::num_keys() const
        {
            return mKeyLabels.size() ;
        }
 
//------------------------------------------------------------------------------
 
        inline const string &
        Section::key( const index_t aIndex ) const
        {
            return mKeyLabels( aIndex );
        }
 
//------------------------------------------------------------------------------
 
        inline const Section *
        Section::section( const index_t aIndex ) const
        {
            return mData( aIndex );
        }
 
//------------------------------------------------------------------------------
 
        inline index_t
        Section::start() const
        {
            return mStartFlag ;
        }
 
//------------------------------------------------------------------------------
 
        inline index_t
        Section::end() const
        {
            return mEndFlag ;
        }
 
//------------------------------------------------------------------------------
 
        inline bool
        Section::section_exists( const string & aSection ) const
        {
            // section types are lowercased when the file is parsed
            // ( get_type ), exactly as key names are, so the lookup must
            // lowercase its argument too. Keys have always done this; the
            // section lookups did not, which made 'Defect' miss a 'defect'
            // that the parser had already folded to lower case
            return mSections.key_exists( string_to_lower( aSection ) );
        }
 
//------------------------------------------------------------------------------
 
        inline bool
        Section::section_exists( const string & aType, const string & aLabel ) const
        {
            // both halves are lowercased at parse ( get_type / get_label )
            string tSection = string_to_lower( aType ) + ":"
                            + string_to_lower( aLabel ) ;
            return mSections.key_exists( tSection );
        }
 
//------------------------------------------------------------------------------
 
        inline const Cell< string > &
        Section::buffer() const
        {
            return mBuffer ;
        }
 
//------------------------------------------------------------------------------
    }
}
 
#endif //BELFEM_CL_INPUT_SECTION_HPP