vala/valamemberaccess.vala

   1 /* valamemberaccess.vala
   2  *
   3  * Copyright (C) 2006-2007  Jürg Billeter
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Jürg Billeter <j@bitron.ch>
  21  */
  22
  23 using GLib;
  24
  25 /**
  26  * Represents an access to a type member in the source code.
  27  */
  28 public class Vala.MemberAccess : Expression {
  29         /**
  30          * The parent of the member.
  31          */
  32         public Expression inner {
  33                 get {
  34                         return _inner;
  35                 }
  36                 set {
  37                         _inner = value;
  38                         if (_inner != null) {
  39                                 _inner.parent_node = this;
  40                         }
  41                 }
  42         }
  43
  44         /**
  45          * The name of the member.
  46          */
  47         public string! member_name { get; set construct; }
  48
  49         private Expression _inner;
  50         private List<TypeReference> type_argument_list;
  51
  52         /**
  53          * Creates a new member access expression.
  54          *
  55          * @param inner  parent of the member
  56          * @param member member name
  57          * @param source reference to source code
  58          * @return       newly created member access expression
  59          */
  60         public MemberAccess (Expression _inner, string! member, SourceReference source = null) {
  61                 inner = _inner;
  62                 member_name = member;
  63                 source_reference = source;
  64         }
  65
  66         public MemberAccess.simple (string! member, SourceReference source = null) {
  67                 member_name = member;
  68                 source_reference = source;
  69         }
  70
  71         /**
  72          * Appends the specified type as generic type argument.
  73          *
  74          * @param arg a type reference
  75          */
  76         public void add_type_argument (TypeReference! arg) {
  77                 type_argument_list.append (arg);
  78         }
  79
  80         /**
  81          * Returns a copy of the list of generic type arguments.
  82          *
  83          * @return type argument list
  84          */
  85         public List<weak TypeReference> get_type_arguments () {
  86                 return type_argument_list.copy ();
  87         }
  88
  89         public override void accept (CodeVisitor! visitor) {
  90                 if (inner != null) {
  91                         inner.accept (visitor);
  92                 }
  93
  94                 foreach (TypeReference type_arg in type_argument_list) {
  95                         type_arg.accept (visitor);
  96                 }
  97
  98                 visitor.visit_member_access (this);
  99         }
 100
 101         public override string! to_string () {
 102                 if (inner == null) {
 103                         return member_name;
 104                 } else {
 105                         return "%s.%s".printf (inner.to_string (), member_name);
 106                 }
 107         }
 108
 109         public override void replace (CodeNode! old_node, CodeNode! new_node) {
 110                 if (inner == old_node) {
 111                         inner = (Expression) new_node;
 112                 }
 113         }
 114 }