JavaPackageName.cs

Go to the documentation of this file.

using System;
 
using IKVM.Runtime.Extensions;
 
namespace IKVM.Runtime.Syntax
{
 
    readonly struct JavaPackageName
    {
 
        public static JavaPackageName Empty => new(ReadOnlyMemory<char>.Empty);
 
        public static implicit operator string(JavaPackageName packageName) => packageName.ToString();
        public static implicit operator JavaPackageName(string packageName) => new(packageName);
 
        public static implicit operator ReadOnlyMemory<char>(JavaPackageName packageName) => packageName.value;
        public static implicit operator JavaPackageName(ReadOnlyMemory<char> packageName) => new(packageName);
 
        public static bool operator ==(JavaPackageName a, JavaPackageName b) => a.value.Span.Equals(b.value.Span, StringComparison.Ordinal);
        public static bool operator !=(JavaPackageName a, JavaPackageName b) => a.value.Span.Equals(b.value.Span, StringComparison.Ordinal) == false;
 
        readonly ReadOnlyMemory<char> value;
 
        public JavaPackageName(string qualifiedName) :
            this(qualifiedName.AsMemory())
        {
            if (qualifiedName is null)
                throw new ArgumentNullException(nameof(qualifiedName));
        }
 
        public JavaPackageName(ReadOnlyMemory<char> qualifiedName)
        {
            this.value = qualifiedName;
        }
 
        public JavaPackageName(JavaPackageName parent, ReadOnlyMemory<char> name) :
            this(parent.IsEmpty ? name : $"{parent}.{name}".AsMemory())
        {
 
        }
 
        public JavaPackageName(JavaPackageName parent, string name) :
            this(parent, name.AsMemory())
        {
            if (name is null)
                throw new ArgumentNullException(nameof(name));
        }
 
        public ReadOnlyMemory<char> Value => value;
 
        public bool IsEmpty => value.IsEmpty;
 
        public JavaSimplePackageName SimpleName => GetSimpleName();
 
        JavaSimplePackageName GetSimpleName()
        {
            if (IsEmpty)
                return JavaSimplePackageName.Empty;
 
            var index = value.Span.LastIndexOf('.');
            return index != -1 ? new JavaSimplePackageName(value.Slice(index + 1)) : JavaSimplePackageName.Empty;
        }
 
        public JavaPackageName Parent => GetParent();
 
        JavaPackageName GetParent()
        {
            var i = value.Span.LastIndexOf('.');
            return i != -1 ? new JavaPackageName(value.Slice(0, i)) : Empty;
        }
 
        public bool IsMemberOf(JavaPackageName packageName) => Parent == packageName;
 
        public bool IsChildOf(JavaPackageName other)
        {
            // the empty package can never be a child of another package
            if (value.IsEmpty)
                return false;
 
            // but everything is a child of it
            if (other.IsEmpty)
                return true;
 
            // we're going to enumerate each package element in the other package and test we can advance through that in the target
            var o = new ReadOnlySpanSeparatorEnumerator(other.value.Span, '.');
            var e = new ReadOnlySpanSeparatorEnumerator(value.Span, '.');
            while (o.MoveNext())
            {
                // for each item in the other, we should be able to advance
                if (e.MoveNext() == false)
                    return false;
 
                // each item must match
                if (e.Current.Equals(o.Current, StringComparison.Ordinal) == false)
                    return false;
            }
 
            // there must still be more elements
            return e.MoveNext();
        }
 
        public bool Equals(JavaPackageName other) => value.Span.Equals(other.value.Span, StringComparison.Ordinal);
 
        public override bool Equals(object obj) => false;
 
        public override int GetHashCode() => value.Span.GetHashCodeExtension();
 
        public override string ToString() => value.Span.ToString();
 
    }
 
}