/// <summary>
 /// Allocates an object that represents a .NET assembly.
 /// </summary>
 /// <param name="name">The name of the unit.</param>
 /// <param name="location">An indication of the location where the unit is or will be stored. This need not be a file system path and may be empty. 
 /// The interpretation depends on the IMetadataHost instance used to resolve references to this unit.</param>
 /// <param name="moduleName">The name of the module containing the assembly manifest. This can be different from the name of the assembly itself.</param>
 /// <param name="assemblyReferences">A list of the assemblies that are referenced by this module.</param>
 /// <param name="moduleReferences">A list of the modules that are referenced by this module.</param>
 /// <param name="resources">A list of named byte sequences persisted with the assembly and used during execution, typically via .NET Framework helper classes.</param>
 /// <param name="files">
 /// A list of the files that constitute the assembly. These are not the source language files that may have been
 /// used to compile the assembly, but the files that contain constituent modules of a multi-module assembly as well
 /// as any external resources. It corresonds to the File table of the .NET assembly file format.
 /// </param>
 protected Assembly(IName name, string location, IName moduleName, IEnumerable<IAssemblyReference> assemblyReferences, IEnumerable<IModuleReference> moduleReferences,
   IEnumerable<IResourceReference> resources, IEnumerable<IFileReference> files)
   : base(name, location, Dummy.Assembly, assemblyReferences, moduleReferences) {
   this.moduleName = moduleName;
   this.resources = resources;
   this.files = files;
 }

   public VccAssembly(IName name, string location, ISourceEditHost hostEnvironment, VccOptions options,
 IEnumerable<IAssemblyReference> assemblyReferences, IEnumerable<IModuleReference> moduleReferences, IEnumerable<VccSourceDocument> programSources)
       : base(name, location, name, assemblyReferences, moduleReferences, new List<IResourceReference>(0).AsReadOnly(), new List<IFileReference>(0).AsReadOnly())
   {
       this.options = options;
         this.hostEnvironment = hostEnvironment;
         this.programSources = programSources;
   }

        /**
         * For manipulating the internals of {@link HSSFName} during Testing.<br/>
         * Some Tests need a {@link NameRecord} with unusual state, not normally producible by POI.
         * This method achieves the aims at low cost without augmenting the POI usermodel api.
         * @return a reference to the wrapped {@link NameRecord} 
         */
        public static NameRecord GetNameRecord(IName definedName)
        {

            FieldInfo f;
            f = typeof(HSSFName).GetField("_definedNameRec",BindingFlags.Instance|BindingFlags.NonPublic);
            //f.SetAccessible(true);
            return (NameRecord)f.GetValue(definedName);
        }

        //
        // CONSTRUCTOR
        //
        public GeometricNetworkLoader(byte[] bytes)
        {
            // Cast byte to object
            object obj = (object)bytes;

            // Unpack dropped object to Esri name enumerator
            INameFactory nameFactory = new NameFactoryClass();
            IEnumName enumName = nameFactory.UnpackageNames(ref obj);
            this._name = enumName.Next();
        }

 /// <summary>
 /// Allocates an object that represents a source document, such as a file, which is parsed according to the rules of a particular langauge, 
 /// such as C#, to produce an object model.
 /// </summary>
 /// <param name="name">The name of the document. Used to identify the document in user interaction.</param>
 protected SourceDocument(IName name) {
   this.name = name;
 }

 /// <summary>
 /// Allocates an object that represents a source document, such as file, which is parsed according to the rules of a particular langauge, 
 /// such as C#, to produce an object model.
 /// </summary>
 /// <param name="name">The name of the document. Used to identify the document in user interaction.</param>
 /// <param name="location">The location where the document was found or where it will be stored.</param>
 /// <param name="streamReader">A StreamReader instance whose BaseStream produces the contents of the document.</param>
 protected PrimarySourceDocument(IName name, string location, StreamReader streamReader)
   : base(name) {
   this.location = location;
   this.GetOwnStreamReaderAndReadAhead(streamReader);
 }

 uint IInternFactory.GetNestedTypeReferenceInternedKey(ITypeReference containingTypeReference, IName typeName, uint genericParameterCount) {
   lock (GlobalLock.LockingObject) {
     return this.GetNestedTypeReferenceInternId(containingTypeReference, typeName, genericParameterCount);
   }
 }

 /// <summary>
 /// Initializes a unit of metadata stored as a single artifact and potentially produced and revised independently from other units.
 /// Examples of units include .NET assemblies and modules, as well C++ object files and compiled headers.
 /// </summary>
 /// <param name="name">The name of the unit.</param>
 /// <param name="location">An indication of the location where the unit is or will be stored. This need not be a file system path and may be empty. 
 /// The interpretation depends on the ICompilationHostEnviroment instance used to resolve references to this unit.</param>
 protected Unit(IName name, string location) {
   this.name = name;
   this.location = location;
 }

 internal NamespaceName(INameTable nameTable, NamespaceName/*?*/ parentNamespaceName, IName name) {
   this.ParentNamespaceName = parentNamespaceName;
   this.Name = name;
   if (parentNamespaceName == null)
     this.FullyQualifiedName = name;
   else
     this.FullyQualifiedName = nameTable.GetNameFor(parentNamespaceName.FullyQualifiedName.Value + "." + name);
 }

 internal FieldOrPropertyNamedArgumentExpression(
   IName name,
   ITypeReference containingType,
   bool isField,
   ITypeReference fieldOrPropTypeReference,
   ExpressionBase expressionValue
 ) {
   this.Name = name;
   this.ContainingType = containingType;
   if (isField)
     this.Flags |= FieldOrPropertyNamedArgumentExpression.IsFieldFlag;
   this.fieldOrPropTypeReference = fieldOrPropTypeReference;
   this.ExpressionValue = expressionValue;
 }

 public IEnumerable<ITypeDefinitionMember> GetMatchingMembersNamed(IName name, bool ignoreCase, Function<ITypeDefinitionMember, bool> predicate)
 {
     return IteratorHelper.GetEmptyEnumerable<ITypeDefinitionMember>();
 }

 public IEnumerable<ITypeDefinitionMember> GetMembersNamed(IName name, bool ignoreCase)
 {
     return IteratorHelper.GetEmptyEnumerable<ITypeDefinitionMember>();
 }

 internal NamespaceTypeName(INameTable nameTable, NamespaceName/*?*/ namespaceName, IName name) {
   this.NamespaceName = namespaceName;
   this.Name = name;
   string nameStr = null;
   TypeCache.SplitMangledTypeName(name.Value, out nameStr, out this.genericParameterCount);
   if (this.genericParameterCount > 0)
     this.unmanagledTypeName = nameTable.GetNameFor(nameStr);
   else
     this.unmanagledTypeName = name;
 }

 /// <summary>
 /// Allocates an object that represents a .NET module.
 /// </summary>
 /// <param name="name">The name of the unit.</param>
 /// <param name="location">An indication of the location where the unit is or will be stored. This need not be a file system path and may be empty. 
 /// The interpretation depends on the ICompilationHostEnviroment instance used to resolve references to this unit.</param>
 /// <param name="containingAssembly">The assembly that contains this module.</param>
 /// <param name="assemblyReferences">A list of the assemblies that are referenced by this module.</param>
 /// <param name="moduleReferences">A list of the modules that are referenced by this module.</param>
 protected Module(IName name, string location, IAssembly containingAssembly, IEnumerable<IAssemblyReference> assemblyReferences, IEnumerable<IModuleReference> moduleReferences)
   : base(name, location) {
   this.containingAssembly = containingAssembly;
   this.assemblyReferences = assemblyReferences;
   this.moduleReferences = moduleReferences;
 }

    uint GetNestedTypeReferenceInternId(ITypeReference containingTypeReference, IName typeName, uint genericParameterCount) {
      Contract.Requires(containingTypeReference != null);
      Contract.Requires(typeName != null);

      uint containingTypeReferenceInteredId = this.GetTypeReferenceInternId(containingTypeReference);
      foreach (NestedTypeStore nstTypeStore in this.NestedTypeHashtable.GetValuesFor((uint)typeName.UniqueKey)) {
        if (
          nstTypeStore.ContainingTypeInternedId == containingTypeReferenceInteredId
          && nstTypeStore.GenericParameterCount == genericParameterCount
        ) {
          return nstTypeStore.InternedId;
        }
      }
      NestedTypeStore nstTypeStore1 = new NestedTypeStore(containingTypeReferenceInteredId, genericParameterCount, this.CurrentTypeInternValue++);
      this.NestedTypeHashtable.Add((uint)typeName.UniqueKey, nstTypeStore1);
      return nstTypeStore1.InternedId;
    }

 internal NestedTypeName(INameTable nameTable, NominalTypeName containingTypeName, IName mangledName) {
   this.ContainingTypeName = containingTypeName;
   this.Name = mangledName;
   string nameStr = null;
   TypeCache.SplitMangledTypeName(mangledName.Value, out nameStr, out this.genericParameterCount);
   this.unmangledTypeName = nameTable.GetNameFor(nameStr);
 }

 /// <summary>
 /// Check if the given <see cref="IName"/> instance has the same <see cref="Name"/> as this instance.
 /// </summary>
 /// <returns>
 /// <c>true</c> if the given <see cref="IName"/> instance has the same <see cref="Name"/> as this instance;
 /// <c>false</c> otherwise.
 /// </returns>
 /// <param name='other'>
 /// The <see cref="IName"/> instance to compare with.
 /// </param>
 public virtual bool EqualName(IName other)
 {
     return this.Name == other.Name;
 }

 internal ScannerState(
   int currentIndex,
   TypeNameTokenKind currentTypeNameTokenKind,
   IName currentIdentifierInfo
 ) {
   this.CurrentIndex = currentIndex;
   this.CurrentTypeNameTokenKind = currentTypeNameTokenKind;
   this.CurrentIdentifierInfo = currentIdentifierInfo;
 }

 /// <summary>
 /// Allocates an object that represents a source document that is the composition of an ordered enumeration of fragments from other source document.
 /// The document is parsed according to the rules of a particular language, such as C#, to produce an object model that can be obtained via the CompilationPart property.
 /// </summary>
 /// <param name="name">The name of the document. Used to identify the document in user interaction.</param>
 protected CompositeSourceDocument(IName name)
   : base(name) {
 }

 public void AddNamedObject(IName namedObject)
 {
     if (namedObject != null)
     {
         this.namedObjects.Add(namedObject.Name, namedObject);
     }
 }