| /******************************************************************************* |
| * Copyright (c) 2016 CEA LIST. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Created on: 18 mars 2011 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #include "ModifierElement.h" |
| |
| #include <sstream> |
| |
| #include <util/avm_string.h> |
| |
| |
| namespace sep |
| { |
| |
| /** |
| * PROPERTY MODIFIER |
| */ |
| Modifier Modifier::PROPERTY_UNDEFINED_MODIFIER; |
| |
| /** |
| * VISIBILITY |
| */ |
| Modifier Modifier::PROPERTY_PUBLIC_MODIFIER( |
| VISIBILITY_PUBLIC_KIND, |
| DIRECTION_UNDEFINED_KIND, |
| NATURE_UNDEFINED_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| Modifier Modifier::PROPERTY_PROTECTED_MODIFIER( |
| VISIBILITY_PROTECTED_KIND, |
| DIRECTION_UNDEFINED_KIND, |
| NATURE_UNDEFINED_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| Modifier Modifier::PROPERTY_PRIVATE_MODIFIER( |
| VISIBILITY_PRIVATE_KIND, |
| DIRECTION_UNDEFINED_KIND, |
| NATURE_UNDEFINED_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| |
| /** |
| * DIRECTION |
| */ |
| Modifier Modifier::PROPERTY_INOUT_DIRECTION( |
| VISIBILITY_UNDEFINED_KIND, |
| DIRECTION_INOUT_KIND, |
| NATURE_UNDEFINED_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| /** |
| * NATURE |
| */ |
| Modifier Modifier::PROPERTY_MACRO_MODIFIER( |
| VISIBILITY_PRIVATE_KIND, |
| DIRECTION_UNDEFINED_KIND, |
| NATURE_MACRO_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| |
| |
| /** |
| * ALIAS |
| */ |
| Modifier Modifier::PROPERTY_PUBLIC_VOLATILE_MODIFIER( |
| VISIBILITY_PUBLIC_KIND, |
| DIRECTION_UNDEFINED_KIND, |
| NATURE_UNDEFINED_KIND, |
| FEATURE_VOLATILE_KIND |
| ); |
| |
| Modifier Modifier::PROPERTY_PUBLIC_FINAL_STATIC_MODIFIER( |
| VISIBILITY_PUBLIC_KIND, |
| DIRECTION_UNDEFINED_KIND, |
| NATURE_UNDEFINED_KIND, |
| FEATURE_FINAL_KIND | FEATURE_STATIC_KIND |
| ); |
| |
| |
| Modifier Modifier::PARAMETER_PUBLIC_FINAL_STATIC_MODIFIER( |
| VISIBILITY_PUBLIC_KIND, |
| DIRECTION_UNDEFINED_KIND, |
| NATURE_PARAMETER_KIND, |
| FEATURE_FINAL_KIND | FEATURE_STATIC_KIND |
| ); |
| |
| |
| /** |
| * [ DIRECTION ] PARAMETER |
| */ |
| Modifier Modifier::PROPERTY_PARAMETER_MODIFIER( |
| VISIBILITY_PRIVATE_KIND, |
| DIRECTION_UNDEFINED_KIND, |
| NATURE_PARAMETER_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| Modifier Modifier::PROPERTY_INPUT_PARAMETER_MODIFIER( |
| VISIBILITY_PRIVATE_KIND, |
| DIRECTION_INPUT_KIND, |
| NATURE_PARAMETER_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| Modifier Modifier::PROPERTY_OUTPUT_PARAMETER_MODIFIER( |
| VISIBILITY_PRIVATE_KIND, |
| DIRECTION_OUTPUT_KIND, |
| NATURE_PARAMETER_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| Modifier Modifier::PROPERTY_INOUT_PARAMETER_MODIFIER( |
| VISIBILITY_PRIVATE_KIND, |
| DIRECTION_INOUT_KIND, |
| NATURE_PARAMETER_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| Modifier Modifier::PROPERTY_RETURN_PARAMETER_MODIFIER( |
| VISIBILITY_PRIVATE_KIND, |
| DIRECTION_RETURN_KIND, |
| NATURE_PARAMETER_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| |
| /** |
| * [ BIND ] PARAMETER |
| */ |
| Modifier Modifier::PROPERTY_PARAMETER_BIND_MODIFIER( |
| VISIBILITY_PRIVATE_KIND, |
| DIRECTION_UNDEFINED_KIND, |
| NATURE_PARAMETER_BIND_KIND, |
| FEATURE_UNDEFINED_KIND |
| ); |
| |
| |
| /** |
| * VISIBILITY KIND to STRING |
| */ |
| std::string Modifier::strVisibility( |
| bit_field_t visibilityKind, const std::string & separator) |
| { |
| switch( visibilityKind ) |
| { |
| // case VISIBILITY_UNDEFINED_KIND: |
| // return( "<visibility:undef>" + separator ); |
| case VISIBILITY_PRIVATE_KIND: |
| // return( "private" + separator ); |
| return( "" ); |
| case VISIBILITY_PUBLIC_KIND: |
| return( "public" + separator ); |
| case VISIBILITY_PROTECTED_KIND: |
| return( "protected" + separator ); |
| case VISIBILITY_PACKAGE_KIND: |
| return( "package" + separator ); |
| |
| default: |
| return( xstrVisibility(visibilityKind, separator) ); |
| } |
| } |
| |
| |
| std::string Modifier::xstrVisibility( |
| bit_field_t visibilityKind, const std::string & separator) |
| { |
| if( (visibilityKind != VISIBILITY_UNDEFINED_KIND) ) |
| // && (visibilityKind != VISIBILITY_PRIVATE_KIND) ) |
| { |
| std::ostringstream oss; |
| |
| if( (visibilityKind & VISIBILITY_PACKAGE_KIND) == |
| VISIBILITY_PACKAGE_KIND ) |
| { |
| oss << "package" << separator; |
| } |
| else if( (visibilityKind & VISIBILITY_PUBLIC_KIND) != 0 ) |
| { |
| oss << "public" << separator; |
| } |
| else if( (visibilityKind & VISIBILITY_PROTECTED_KIND) != 0 ) |
| { |
| oss << "protected" << separator; |
| } |
| |
| return( oss.str() ); |
| } |
| |
| return( "<visibility:undef>" ); |
| } |
| |
| |
| /** |
| * DIRECTION KIND to STRING |
| */ |
| std::string Modifier::strDirection( |
| bit_field_t directionKind, const std::string & separator) |
| { |
| switch( directionKind ) |
| { |
| case DIRECTION_UNDEFINED_KIND: |
| return( "" ); |
| |
| case DIRECTION_INPUT_KIND: |
| return( "input" + separator ); |
| case DIRECTION_OUTPUT_KIND: |
| return( "output" + separator ); |
| case DIRECTION_INOUT_KIND: |
| return( "inout" + separator ); |
| case DIRECTION_RETURN_KIND: |
| return( "return" + separator ); |
| |
| default: |
| return( xstrDirection(directionKind, separator) ); |
| } |
| } |
| |
| std::string Modifier::xstrDirection( |
| bit_field_t directionKind, const std::string & separator) |
| { |
| if( (directionKind != DIRECTION_UNDEFINED_KIND) ) |
| { |
| std::ostringstream oss; |
| |
| if( (directionKind & DIRECTION_RETURN_KIND) != 0 ) |
| { |
| oss << "return" << separator; |
| } |
| |
| if( (directionKind & DIRECTION_INOUT_KIND) == DIRECTION_INOUT_KIND ) |
| { |
| oss << "inout" << separator; |
| } |
| else if( (directionKind & DIRECTION_INPUT_KIND) != 0 ) |
| { |
| oss << "input" << separator; |
| } |
| else if( (directionKind & DIRECTION_OUTPUT_KIND) != 0 ) |
| { |
| oss << "output" << separator; |
| } |
| |
| return( oss.str() ); |
| } |
| |
| return( "<direction:undef>" ); |
| } |
| |
| |
| Modifier::DIRECTION_KIND Modifier::toDirectionKind(const std::string & id) |
| { |
| if( id == "inout" ) return DIRECTION_INOUT_KIND; |
| if( id == "input" ) return DIRECTION_INPUT_KIND; |
| if( id == "output" ) return DIRECTION_OUTPUT_KIND; |
| |
| return DIRECTION_UNDEFINED_KIND; |
| } |
| |
| |
| /** |
| * FEATURE KIND to STRING |
| */ |
| std::string Modifier::strFeature( |
| bit_field_t featureKind, const std::string & separator) |
| { |
| if( featureKind != FEATURE_UNDEFINED_KIND ) |
| { |
| std::ostringstream oss; |
| |
| if( (featureKind & FEATURE_FINAL_KIND) != 0 ) |
| { |
| oss << "final" << separator; |
| } |
| if( (featureKind & FEATURE_STATIC_KIND) != 0 ) |
| { |
| oss << "static" << separator; |
| } |
| if( (featureKind & FEATURE_TRANSIENT_KIND) != 0 ) |
| { |
| oss << "transient" << separator; |
| } |
| if( (featureKind & FEATURE_VOLATILE_KIND) != 0 ) |
| { |
| oss << "volatile" << separator; |
| } |
| if( (featureKind & FEATURE_UNSAFE_KIND) != 0 ) |
| { |
| oss << "unsafe" << separator; |
| } |
| |
| return( oss.str() ); |
| } |
| |
| return( "" /*"<feature:undef>"*/ ); |
| } |
| |
| |
| /** |
| * NATURE KIND to STRING |
| */ |
| std::string Modifier::strNature( |
| bit_field_t nature, const std::string & separator) |
| { |
| if( (nature != NATURE_UNDEFINED_KIND) ) |
| // && (nature != NATURE_VARIABLE_KIND) ) |
| { |
| std::ostringstream oss; |
| |
| if( (nature & NATURE_REFERENCE_KIND) != 0 ) |
| { |
| oss << "reference" << separator; |
| } |
| if( (nature & NATURE_MACRO_KIND) != 0 ) |
| { |
| oss << "macro" << separator; |
| } |
| if( (nature & NATURE_BIND_KIND) != 0 ) |
| { |
| oss << "bind" << separator; |
| } |
| |
| if( (nature & NATURE_PARAMETER_KIND) != 0 ) |
| { |
| oss << "parameter" << separator; |
| } |
| |
| return( oss.str() ); |
| } |
| |
| return( "" /*"<nature:undef>"*/ ); |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| std::string Modifier::toString(bit_field_t enabledFields, |
| const std::string & separator) const |
| { |
| std::ostringstream oss; |
| |
| if( (enabledFields & FIELD_VISIBILITY_POSITION) != 0 ) |
| { |
| oss << Modifier::strVisibility( visibility , separator ); |
| } |
| |
| if( (enabledFields & FIELD_DIRECTION_POSITION) != 0 ) |
| { |
| oss << Modifier::strDirection ( direction , separator ); |
| } |
| |
| if( (enabledFields & FIELD_FEATURE_POSITION) != 0 ) |
| { |
| oss << Modifier::strFeature( feature , separator ); |
| } |
| |
| if( (enabledFields & FIELD_NATURE_POSITION) != 0 ) |
| { |
| oss << Modifier::strNature ( nature , separator ); |
| } |
| |
| return( oss.str() ); |
| } |
| |
| |
| } |