public FieldContext FieldFromTrip(TripField field)
        {
            var fc = new FieldContext(
                    field.Name,
                    (short)field.Identifier,
                    //typeConverter.ConvertToString(field.Type),
                    MangleCSharpMethodName(field.Name),
                    MangleCSharpTypeName(field.Name),
                    field.Required == Required.REQUIRED,
                    typeConverter.ConvertToGenType(field.Type)
                );

            return fc;

        }
 private string SetterName(TripField field)
 {
     return "set" + MangleJavaTypeName(field.Name);
 }
 private string GetterName(TripField field)
 {
     string type = typeConverter.ConvertToString(field.Type);
     return ("Boolean".Equals(type) ? "is" : "get") + MangleJavaTypeName(field.Name);
 }
 public void Visit(TripField tripField)
 {
     sb.Append(tripField.Identifier).Append(": ");
     if (tripField.Required != Required.NONE)
     {
         sb.Append(tripField.Required.ToString().ToLower()).Append(" ");
     }
     VisitTripType(tripField.Type);
     sb.Append(" ").Append(tripField.Name).Append(" ");
 }
 public void Visit(TripField tripField)
 {
     throw new NotImplementedException();
 }
        public static List<TripField> BuildTripFields(ParseTreeNode tripFieldNodes, string structName)
        {
            List<TripField> tripFields = new List<TripField>();
            ISet<long> fieldIdSet = new HashSet<long>();
            foreach (var fieldNode in tripFieldNodes.ChildNodes)
            {
                string fieldName = null;
                long fieldId = -1L;
                Required fieldReq = Required.NONE;
                TripType fieldType = null;
                foreach (var fieldChildNode in fieldNode.ChildNodes)
                {
                    if (fieldChildNode.Term.Name == IdlGrammar.NTNAME_TFIELD_ID &&
                        fieldChildNode.ChildNodes.Count > 0)
                    {
                        var fieldIdText = fieldChildNode.ChildNodes[0].FindTokenAndGetText();
                        fieldId = long.Parse(fieldIdText);
                    }
                    else if (fieldChildNode.Term.Name == IdlGrammar.NTNAME_FIELD_REQ &&
                             fieldChildNode.ChildNodes.Count > 0)
                    {
                        var fieldReqText = fieldChildNode.ChildNodes[0].FindTokenAndGetText();
                        if (fieldReqText == "required")
                        {
                            fieldReq = Required.REQUIRED;
                        }
                        else if (fieldReqText == "optional")
                        {
                            fieldReq = Required.OPTIONAL;
                        }
                        else
                        {
                            fieldReq = Required.NONE;
                        }
                    }
                    else if (fieldChildNode.Term.Name == IdlGrammar.NTNAME_TFIELD_TYPE)
                    {
                        fieldType = BuildFieldType(fieldChildNode);
                    }
                    else if (fieldChildNode.Term.Name == IdlGrammar.TNAME_TIDENTIFIER)
                    {
                        fieldName = fieldChildNode.Token.Text;
                    }
                }

                var tripField = new TripField(fieldName, fieldType, fieldId, fieldReq);
                if (fieldId <= 0)
                {
                    throw new ArgumentException(string.Format("FieldId {0} defined in struct '{1}' is not positive", fieldId, structName));
                }
                if (fieldIdSet.Contains(fieldId))
                {
                    throw new ArgumentException(string.Format("FieldId {0} defined in struct '{1}' is not unique", fieldId, structName));
                }

                fieldIdSet.Add(fieldId);
                tripFields.Add(tripField);
            }

            return tripFields;
        }