public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (obj.GetType() == typeof(CppTypes))
{
return(Equals(new CppType(obj)));
}
if (obj.GetType() != typeof(CppType))
{
return(false);
}
CppType other = (CppType)obj;
return((((internalModifiers == null || !internalModifiers.Any()) &&
(other.internalModifiers == null || !other.internalModifiers.Any())) ||
(internalModifiers != null && other.internalModifiers != null &&
CppModifiers.NormalizeOrder(internalModifiers).SequenceEqual(CppModifiers.NormalizeOrder(other.internalModifiers)))) &&
(((Namespaces == null || !Namespaces.Any()) &&
(other.Namespaces == null || !other.Namespaces.Any())) ||
(Namespaces != null && other.Namespaces != null &&
Namespaces.SequenceEqual(other.Namespaces))) &&
ElementType == other.ElementType &&
ElementTypeName == other.ElementTypeName);
}
public CppType Subtract(CppModifiers modifier)
{
CppType newType = this;
newType.internalModifiers = new List <CppModifiers> (((IEnumerable <CppModifiers>)newType.Modifiers).Reverse().WithoutFirst(modifier));
return(newType);
}
// note: this adds modifiers "backwards" (it is mainly used by the generator)
public CppType Modify(CppModifiers modifier)
{
CppType newType = this;
var newModifier = new CppModifiers [] { modifier };
if (newType.internalModifiers != null)
{
newType.internalModifiers.AddFirst(newModifier);
}
else
{
newType.internalModifiers = new List <CppModifiers> (newModifier);
}
return(newType);
}
// FIXME: This makes no attempt to actually verify that the parts compose a valid C++ type.
private void Parse(object [] parts)
{
foreach (object part in parts)
{
if (part is CppModifiers)
{
Modifiers.Add((CppModifiers)part);
continue;
}
if (part is CppModifiers [] || part is IEnumerable <CppModifiers> )
{
Modifiers.AddRange((IEnumerable <CppModifiers>)part);
continue;
}
if (part is CppTypes)
{
ElementType = (CppTypes)part;
continue;
}
Type managedType = part as Type;
if (managedType != null)
{
CppType mapped = CppType.ForManagedType(managedType);
CopyTypeFrom(mapped);
continue;
}
string strPart = part as string;
if (strPart != null)
{
var parsed = CppModifiers.Parse(strPart);
if (parsed.Count > 0)
{
if (internalModifiers == null)
{
internalModifiers = parsed;
}
else
{
internalModifiers.AddRange(parsed);
}
strPart = CppModifiers.Remove(strPart);
}
// if we have something left, it must be a type name
strPart = strPart.Trim();
if (strPart != "")
{
string [] qualifiedName = strPart.Split(new string [] { "::" }, StringSplitOptions.RemoveEmptyEntries);
int numNamespaces = qualifiedName.Length - 1;
if (numNamespaces > 0)
{
Namespaces = new string [numNamespaces];
for (int i = 0; i < numNamespaces; i++)
{
Namespaces [i] = qualifiedName [i];
}
}
strPart = qualifiedName [numNamespaces];
// FIXME: Fix this mess
switch (strPart)
{
case "void":
ElementType = CppTypes.Void;
break;
case "bool":
ElementType = CppTypes.Bool;
break;
case "char":
ElementType = CppTypes.Char;
break;
case "int":
ElementType = CppTypes.Int;
break;
case "float":
ElementType = CppTypes.Float;
break;
case "double":
ElementType = CppTypes.Double;
break;
default:
// otherwise it is the element type name...
ElementTypeName = strPart;
break;
}
}
}
}
}
// note: this adds modifiers "backwards" (it is mainly used by the generator)
public CppType Modify (CppModifiers modifier)
{
CppType newType = this;
var newModifier = new CppModifiers [] { modifier };
if (newType.internalModifiers != null)
newType.internalModifiers.AddFirst (newModifier);
else
newType.internalModifiers = new List<CppModifiers> (newModifier);
return newType;
}
public CppType Subtract (CppModifiers modifier)
{
CppType newType = this;
newType.internalModifiers = new List<CppModifiers> (((IEnumerable<CppModifiers>)newType.Modifiers).Reverse ().WithoutFirst (modifier));
return newType;
}
