mirror of
https://github.com/eclipse-openvehicle-api/openvehicle-api.git
synced 2026-02-05 07:18:44 +00:00
250 lines
12 KiB
C++
250 lines
12 KiB
C++
#ifndef DEFINITION_ENTITY_H
|
|
#define DEFINITION_ENTITY_H
|
|
|
|
#include "entity_base.h"
|
|
|
|
/**
|
|
* @brief Support flags for the content of a definition (the part between the curly brackets '{...}').
|
|
*/
|
|
enum class EDefinitionSupport : uint32_t
|
|
{
|
|
support_variable, ///< Support variable declarations.
|
|
support_const_variable, ///< Support const variable declarations.
|
|
support_case_declaration, ///< Support case declarations.
|
|
support_enum_entry, ///< Support enumerator entry.
|
|
support_module, ///< Support module definitions.
|
|
support_typedef, ///< Support typedef declarations.
|
|
support_interface, ///< Support interface definitions.
|
|
support_struct, ///< Support struct definitions.
|
|
support_union, ///< Support union definitions.
|
|
support_enum, ///< Support enum definitions.
|
|
support_exception, ///< Support exception definitions.
|
|
support_attribute, ///< Support attribute declarations.
|
|
support_operation, ///< Support operation declarations.
|
|
};
|
|
|
|
/**
|
|
* @brief The base for definition entity definitions within an IDL file (struct, union, exception, interface, enum).
|
|
* @details The definition entity definitions all have a similar setup with small differences in detail. Consider the following
|
|
* structures:
|
|
* @code
|
|
* struct <name | anonymous> : <inheritance list> { <member list> }
|
|
* union <name | anonymous> switch(<type>) { <case member list> }
|
|
* interface <name> : <inheritance list> { <member list> }
|
|
* exception <name> { <member list> }
|
|
* enum <name> : <type> { <item list> }
|
|
* @endcode
|
|
* The following generalized structure applies to all complex structures:
|
|
* @code
|
|
* keyword name
|
|
* prefix keyword name postfix { definition }
|
|
* @endcode
|
|
* The first statement is a forward declaration. The second represents the type definition.
|
|
* The prefix is used to provide a specific interpretation to the definition.
|
|
* The keyword defines the type of definition (can be struct, union, interface, exception, enum).
|
|
* The name is the defined name of the definition. For types that allow anonymous names, this part is optionally.
|
|
* The postfix allows the specification of additional information needed for the definition (inheritynce list, switch list).
|
|
* The definition defines the content of the type.
|
|
* Some declarations might start as a type definition (e.g. struct, union, enum) followed with a declaration. For example:
|
|
* @code
|
|
* struct <def_name> { <definition> } <decl_name>
|
|
* struct { <definition> } <decl_name>
|
|
* @endcode
|
|
* In the first statement, the struct is defined and declared in one statement. In the second statement, an anonymous struct is
|
|
* defined and declared in one statement.
|
|
*/
|
|
class CDefinitionEntity : public CEntity, public sdv::idl::IDefinitionEntity
|
|
{
|
|
public:
|
|
/**
|
|
* @brief Default constructor
|
|
* @param[in] rptrContext Reference to the smart pointer holding the parse context. Must not be NULL.
|
|
* @param[in] ptrParent Pointer to the parent class holding this entity. This must not be NULL.
|
|
*/
|
|
CDefinitionEntity(const CContextPtr& rptrContext, CEntityPtr ptrParent);
|
|
|
|
protected:
|
|
/**
|
|
* @brief Root entity constructor (name is 'root' and no parent).
|
|
* @param[in] rParser Reference to the parser.
|
|
* @param[in] rptrContext Reference to the smart pointer holding the parse context. Must not be NULL.
|
|
*/
|
|
CDefinitionEntity(CParser& rParser, const CContextPtr& rptrContext);
|
|
public:
|
|
|
|
/**
|
|
* @brief Destructor
|
|
*/
|
|
virtual ~CDefinitionEntity() override = default;
|
|
|
|
/**
|
|
* @brief Get access to another interface. Overload of IInterfaceAccess::GetInterface.
|
|
* @param[in] idInterface The interface id to get access to.
|
|
* @return Returns a pointer to the interface or NULL when the interface is not supported.
|
|
*/
|
|
virtual sdv::interface_t GetInterface(sdv::interface_id idInterface) override;
|
|
|
|
/**
|
|
* @brief Process the content of the definition.
|
|
* @details Process the content of the definition. This function parses through the content until a closing curly bracket
|
|
* has been detected. First the function checks for prefixes. Then the function determines whether the statement is a
|
|
* declaration or a definition. It then creates the corresponding entity and let the entity process itself.
|
|
*/
|
|
virtual void ProcessContent();
|
|
|
|
/**
|
|
* @brief Process the code. Overload of CEntity::Process.
|
|
*/
|
|
virtual void Process() override;
|
|
|
|
/**
|
|
* @brief Process the definition addendum.
|
|
* @details Process the definition addendum following the definition statement before the content definition. The default
|
|
* implementation checks for an inheritance list.
|
|
*/
|
|
virtual void ProcessDefinitionAddendum();
|
|
|
|
/**
|
|
* @brief Create a values for inherited child nodes.
|
|
*/
|
|
void CreateInheritanceValueChildNodes();
|
|
|
|
/**
|
|
* @brief Does the entity have an Unnamed definition. Overload of IDefinitionEntity::Unnamed.
|
|
* @return Returns 'true' when the definition supports unnamed definition; 'false' otherwise.
|
|
*/
|
|
virtual bool IsUnnamed() const override { return m_bAnonymousDefinition; };
|
|
|
|
/**
|
|
* @brief Request whether the definition supports the content. This function must be implemented by the derived entity.
|
|
* @param[in] eSupport The type of support that is requested.
|
|
* @return Returns 'true' when the definition supports the content; 'false' otherwise.
|
|
*/
|
|
virtual bool Supports(EDefinitionSupport eSupport) const = 0;
|
|
|
|
/**
|
|
* @brief Does the entity support children? Overload of CEntity::SupportsChildren.
|
|
* @details Complex types support children per default.
|
|
* @return Returns whether the entity supports children (which is the case).
|
|
*/
|
|
virtual bool SupportsChildren() const override { return true; }
|
|
|
|
/**
|
|
* @brief Does the entity support inheritance?
|
|
* @details The default implementation is that inheritance is not supported.
|
|
* @return Returns whether the entity supports inheritance (which is not the case).
|
|
*/
|
|
virtual bool SupportsInheritance() const { return false; }
|
|
|
|
/**
|
|
* @brief Does the entity support anonymous naming?
|
|
* @details The default implementation is that anonymous naming is not supported.
|
|
* @return Returns whether the entity supports inheritance (which is not the case).
|
|
*/
|
|
virtual bool SupportsAnonymous() const { return false; }
|
|
|
|
/**
|
|
* @brief Does the complex entity support attributes in its content?
|
|
* @details The default implementation doesn't support attributes (they are specific to interfaces).
|
|
* @return Returns whether the entity supports attributes (which is not the case).
|
|
*/
|
|
virtual bool SupportContentAttributes() const { return false; }
|
|
|
|
/**
|
|
* @brief Does the complex entity support operations in its content?
|
|
* @details The default implementation doesn't support operations (they are specific to interfaces).
|
|
* @return Returns whether the entity supports operations (which is not the case).
|
|
*/
|
|
virtual bool SupportContentOperations() const { return false; }
|
|
|
|
/**
|
|
* @brief Does the definition entity require a content definition?
|
|
* @details In certain cases, it is required that the content definition is following the definition statement. For example,
|
|
* when an inheritance list is provided. The default implementation checks the m_bRequiresContent variable.
|
|
* @return Returns whether the content definition should be defined following the definition statement.
|
|
*/
|
|
virtual bool RequireContentDefinition() const { return m_bRequiresContent; }
|
|
|
|
/**
|
|
* @brief Does the definition require a declaration?
|
|
* @details In certain cases, it is required that the definition is followed by a declaration. For example,
|
|
* when the definition was made anonymously or when the definition is dependent on a variable within the same struct (e.g. with
|
|
* unions).
|
|
* @return Returns whether the definition requires a declaration.
|
|
*/
|
|
virtual bool RequireDeclaration() const { return IsUnnamed(); }
|
|
|
|
/**
|
|
* @brief Does the definition allow automatic transparent declaration if not present?
|
|
* @details When set an automatic transparent declaration is allowed without an explicit variable declaration. Currently this
|
|
* is only the case with unions with a variable based switch type.
|
|
* @return Returns whether the definition allows an automatic transparent declaration.
|
|
*/
|
|
virtual bool AllowAutoTransparentDeclaration() const { return false; }
|
|
|
|
/**
|
|
* @brief Get child entity iterator if children are available and supported by the definition. Overload of
|
|
* sdv::idl::IDefinitionEntity::GetChildren.
|
|
* @return Returns a pointer to the child entity iterator or NULL when not available.
|
|
*/
|
|
virtual sdv::idl::IEntityIterator* GetChildren() override;
|
|
|
|
/**
|
|
* @brief Get inheritance entity iterator if the definition was inheriting from other entities. Overload of
|
|
* sdv::idl::IDefinitionEntity::GetInheritance.
|
|
* @return Returns a pointer to the inheritance entity iterator or NULL when not available.
|
|
*/
|
|
virtual sdv::idl::IEntityIterator* GetInheritance() override;
|
|
|
|
/**
|
|
* @brief Calculate the hash of this entity and all encapsulated entities. Overload of CBaseEntity::CalcHash.
|
|
* @param[in, out] rHash Hash object to be filled with data.
|
|
*/
|
|
virtual void CalcHash(CHashObject& rHash) const override;
|
|
|
|
/**
|
|
* @brief Get the declaration members.
|
|
* @return List of declaration members.
|
|
*/
|
|
const CEntityList GetDeclMembers() const;
|
|
|
|
protected:
|
|
/**
|
|
* @brief Add the child to the children list. Called by CreateChild function. Overload of CEntity::AddChild.
|
|
* @param[in] ptrChild Pointer to the child entity to add.
|
|
*/
|
|
virtual void AddChild(CEntityPtr ptrChild) override;
|
|
|
|
/**
|
|
* @brief Find the entity locally by looking in the entity children map and the entity children maps of all the chained
|
|
* entities. The search is done case-insensitive. Overload of CEntity::FindLocal.
|
|
* @param[in] rssName Reference to the string object containing the name of the entity to search for.
|
|
* @param[in] bDeclaration When set, the name belongs to a declaration; otherwise it belongs to a definition. Needed to allow
|
|
* the reuse of names between declarations and definitions.
|
|
* @return Returns a pair object containing an entity pointer if the entity exists or a NULL pointer if not as well as a
|
|
* boolean that indicates that the entity was from an inherited entity.
|
|
*/
|
|
virtual std::pair<CEntityPtr, bool> FindLocal(const std::string& rssName, bool bDeclaration) const override;
|
|
|
|
/**
|
|
* @brief Create the content value node. Overridable when supporting content values.
|
|
* @details When supporting value assignments, create the value node and assign the value node to the ValueRef() reference. For
|
|
* definitions that do not support value assignments, do nothing (default).
|
|
*/
|
|
virtual void CreateValueNode() {};
|
|
|
|
protected:
|
|
CEntityVector m_vecInheritance; ///< List of base entities in the order of appearance.
|
|
CEntityList m_lstTypeMembers; ///< List of typedef member declarations and type definitions.
|
|
CEntityList m_lstConstMembers; ///< List of const member declarations.
|
|
CEntityList m_lstDeclMembers; ///< List of variable member declarations.
|
|
CEntityList m_lstAttributesOperation; ///< List with attributes and operations.
|
|
bool m_bRequiresContent = false; ///< When set, the definition statement requires content to follow.
|
|
bool m_bAnonymousDefinition = false; ///< When set, the entity has an anonymous generated name.
|
|
CEntityIterator m_iteratorChildren; ///< Children iterator
|
|
CEntityIterator m_iteratorInheritance; ///< Inheritance iterator
|
|
};
|
|
|
|
|
|
#endif // !defined(DEFINITION_ENTITY_H)
|