dictionary.hpp

Go to the documentation of this file.

/*------------------------------- phasicFlow ---------------------------------
      O        C enter of
     O O       E ngineering and
    O   O      M ultiscale modeling of
   OOOOOOO     F luid flow       
------------------------------------------------------------------------------
  Copyright (C): www.cemf.ir
  email: hamid.r.norouzi AT gmail.com
------------------------------------------------------------------------------  
Licence:
  This file is part of phasicFlow code. It is a free software for simulating 
  granular and multiphase flows. You can redistribute it and/or modify it under
  the terms of GNU General Public License v3 or any other later versions. 
 
  phasicFlow is distributed to help others in their research in the field of 
  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
-----------------------------------------------------------------------------*/
// based on OpenFOAM dictionary, with some modifications/simplifications
// to be tailored to our needs
 
 
#ifndef __dictionary_hpp__
#define __dictionary_hpp__
 
#include "types.hpp"
#include "iEntry.hpp"
#include "dataEntry.hpp"
#include "MapPtr.hpp"
#include "List.hpp"
#include "fileSystem.hpp"
 
namespace pFlow
{
 
class dictionary
:
    public iEntry
{
protected:
 
 
        word name_;
 
        wordOrderedMapPtr<iEntry> entries_;
 
        List<iEntry*> orderedEntries_;
 
        const dictionary& parDict_;
 
        bool isGlobal_ = false;
 
 
 
        iEntry* findEntry(const word& keyword);
 
        iEntry* findEntry(const word& keyword)const;
 
        template<typename T>
        bool readDataEntry( const word& keyword, T& val)const;
 
        bool readDictionary(iIstream & is);
 
        bool writeDictionary(iOstream& os, bool withBlock = true)const;
 
        
    
 
public:
 
    // null dictionary object, to be used for references 
    static dictionary nullDict;
 
    TypeInfo("dictionary");
 
        dictionary(const word& keyword, bool global);
 
        dictionary(const word& keyword, const fileSystem& file);
        
        dictionary();
 
        dictionary(const word& keyword);
 
        dictionary(const word& keyword, const dictionary& parDict);
 
        dictionary( const word& keyword, const dictionary& parDict, iIstream& is);
 
        dictionary(const word& keyword, const dictionary& parDict, const dictionary& dict);
 
        dictionary(const dictionary& );
 
        dictionary(const dictionary& src, bool global);
 
 
        dictionary& operator=(const dictionary& rhs);
 
 
 
        virtual dictionary* dictPtr();
        
        virtual const dictionary* dictPtr() const;
        
        virtual bool isDictionary() const;
 
        virtual word globalName()const;
 
        virtual const dictionary& parrentDict() const;
 
        virtual dictionary& dict();
 
        virtual const dictionary& dict() const;
 
        virtual bool isFileDict()const;
 
        bool addPtr(const word& keyword, uniquePtr<iEntry>& etry, bool warning = true );
 
 
        bool add(const word& keyword, const float& v);
 
        bool add(const word& keyword, const double& v);
 
        bool add(const word& keyword, const word& v);
 
        bool add(const word& keyword, const int64& v);
 
        bool add(const word& keyword, const int32& v);
 
        bool add(const word& keyword, const int8& v);
 
        bool add(const word& keyword, const uint64& v);
 
        bool add(const word& keyword, const uint32& v);
 
        bool add(const word& keyword, const uint8& v);
 
        bool addDict(const word& keyword, const dictionary& dict);
 
        template<typename T>
        bool add(const word& keyword, const T& v );
 
        template<typename T>
        bool addOrKeep(const word& keyword, const T& v);
 
        template<typename T>
        bool addOrReplace(const word& keyword, const T& v);
 
        void clear();
 
        dictionary* subDictPtr(const word& keyword);
 
        dictionary& subDict(const word& keyword);
 
        const dictionary& subDict(const word& keyword) const;
 
        dataEntry* dataEntryPtr(const word& keyword);
 
        dataEntry& dataEntryRef(const word& keyword);
 
        const dataEntry& dataEntryRef(const word& keyword)const;
 
        dictionary& subDictOrCreate(const word& keyword);
        
        template<typename T>
        T getVal(const word& keyword) const;
 
        template<typename T>
        T getValMax(const word& keyword, const T& maxVal)const;
 
        template<typename T>
        T getValMin(const word& keyword, const T& minVal)const;
 
        template<typename T>
        T getValOrSet(const word& keyword, const T& setVal)const;
 
        template<typename T>
        T getValOrSetMax(const word& keyword, const T& setMaxVal)const;
 
        template<typename T>
        T getValOrSetMin(const word& keyword, const T& setMinVal)const;
 
        size_t numEntries()const;
        
        size_t numDataEntries()const;
 
        size_t numDictionaries()const;
 
        wordList allKeywords()const;
 
        wordList dataEntryKeywords()const;
 
        wordList dictionaryKeywords()const;
 
        bool containsDictionay(const word& name)const;
        
        bool containsDataEntry(const word& name)const;
 
        virtual uniquePtr<iEntry> clone() const;
 
        virtual iEntry* clonePtr() const;
 
        virtual uniquePtr<iEntry> clone(const dictionary& parDict)const;
 
        virtual iEntry* clonePtr(const dictionary& parDict) const;
 
 
 
        bool read(iIstream& is) override;
 
        bool write(iOstream& os) const override;
 
};
 
 
 
template<typename T>
bool dictionary::add(const word& keyword, const T& v )
{
 
    uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this ,v);
    return addPtr(keyword, ptr);
        
}
 
 
template<typename T>
bool dictionary::addOrKeep(const word& keyword, const T& v )
{
    if(!containsDataEntry(keyword))
    {
        uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this ,v);
        return addPtr(keyword, ptr);
    }
    
    return true;
}
 
 
template<typename T>
bool dictionary::readDataEntry
(
    const word& keyword,
    T& val
)const 
{
    
    if( auto entry = findEntry(keyword); entry!= nullptr && !entry->isDictionary()  )
    {
        iTstream& is = dynamic_cast<dataEntry&>(*entry).stream();
    
        is >> val;
        return true;
    }
    else
    {
        return false;   
    }
 
}
 
template<typename T>
T dictionary::getVal
(
    const word& keyword
)const 
{
    T val{};
    if(!readDataEntry(keyword, val))
    {
        fatalErrorInFunction <<
        "cannot find dataEntry "<< keyword <<" in dictionary "<< globalName()<<endl;
        fatalExit;
    }
    return val;
}
 
template<typename T>
T dictionary::getValMax
(
    const word& keyword,
    const T& maxVal
)const 
{
    return max(getVal<T>(keyword), maxVal);
}
 
template<typename T>
T dictionary::getValMin
(
    const word& keyword, 
    const T& minVal
)const
{
    return min(getVal<T>(keyword), minVal);
}
 
template<typename T>
T dictionary::getValOrSet
(
    const word& keyword,
    const T& setVal
)const 
{
    T val{};
    if( readDataEntry(keyword, val) )
    {
        return val;
    }
    else
    {
        return setVal;
    }
}
 
template<typename T>
T dictionary::getValOrSetMax(const word& keyword, const T& setMaxVal)const
{
    return max(getValOrSet(keyword, setMaxVal), setMaxVal);
}
 
template<typename T>
T dictionary::getValOrSetMin(const word& keyword, const T& setMinVal)const
{
    return min(getValOrSet(keyword, setMinVal), setMinVal);
}
 
template <typename T>
inline bool dictionary::addOrReplace
(
    const word &keyword, 
    const T &v
)
{
    uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this ,v);
    return addPtr(keyword, ptr, false);
}
 
 
} // pFlow
 
#endif // __dictionary_hpp__