public static String ResourceTypeToString(ResourceType type)
 {
     switch (type)
     {
         case ResourceType.MESH:
             {
                 return "Meshes";
             }
         case ResourceType.FOLDER:
             {
                 return "Folder";
             }
         case ResourceType.MACRO:
             {
                 return "Macros";
             }
         case ResourceType.MATERIAL:
             {
                 return "Materials";
             }
         case ResourceType.SCRIPT:
             {
                 return "Scripts";
             }
         case ResourceType.TEXTURE:
             {
                 return "Textures";
             }
         default:
             return "NONE";
     }
 }

        ResourceType resourceType; // The ResourceType the resource on the map is.

        #endregion Fields

        #region Constructors

        // Default Constructor used for creating an empty Tile object
        public Tile()
        {
            // Initialise the variables to a default state
            position = Vector3.zero;
            resourceType = ResourceType.None;
            resourceObj = null;
        }

		protected NativeObjectSecurity (bool isContainer,
						ResourceType resourceType,
						SafeHandle handle,
						AccessControlSections includeSections)
			: this (isContainer, resourceType, handle, includeSections, null, null)
		{
		}

        private async Task<JobResource> UploadResourceAndGetInfoAsync(string filePath, ResourceType resourceType, string driverUploadPath, string localizedName = null)
        {
            if (!_file.Exists(filePath))
            {
                Exceptions.Throw(
                    new FileNotFoundException("Could not find resource file " + filePath),
                    Log);
            }

            var destinationPath = driverUploadPath + Path.GetFileName(filePath);
            var remoteFileUri = _fileSystem.CreateUriForPath(destinationPath);

            Log.Log(Level.Verbose, @"Copy {0} to {1}", filePath, remoteFileUri);

            // IFileSystem does not support async APIs; Hence we start the copying in a task
            await Task.Run(() => _fileSystem.CopyFromLocal(filePath, remoteFileUri));
            var fileStatus = _fileSystem.GetFileStatus(remoteFileUri);

            return new JobResource
            {
                Name = localizedName ?? Path.GetFileName(filePath),
                LastModificationUnixTimestamp = DateTimeToUnixTimestamp(fileStatus.ModificationTime),
                RemoteUploadPath = _urlConverter.ConvertToLocalUrl(remoteFileUri),
                ResourceSize = fileStatus.LengthBytes,
                ResourceType = resourceType
            };
        }

        private IInMemoryConfigurer AddResourceGroup(string name, Action<IResourceElementGroupConfigurer> registration, ResourceType resourceType)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }
            if (registration == null)
            {
                throw new ArgumentNullException("registration");
            }

            ResourceElementGroup resourceElementGroup = new ResourceElementGroup {ResourceType = resourceType};
            ResourceElementGroupConfigurer resourceElementGroupConfigurer = new ResourceElementGroupConfigurer(resourceElementGroup);
            registration(resourceElementGroupConfigurer);

            if (resourceType == ResourceType.Js)
            {
                m_WebResources.JavascriptResources.ResourceGroups.Add(resourceElementGroup);                
            }
            else if (resourceType == ResourceType.Css)
            {
                m_WebResources.CssResources.ResourceGroups.Add(resourceElementGroup);                
            }
            return this;
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="rt">Tipo de recurso</param>
 /// <param name="qtd">Quantidade do recurso</param>
 public Resource(ResourceType rt, int qtd, Texture2D img)
 {
     Type = rt;
     Quantity = qtd;
     Image = img;
     Name = Enum.GetName(typeof(ResourceType), Type);
 }

        /// <summary>
        /// Performs any transforms on the web <paramref name="resources" /> passed in and returns the new list.
        /// </summary>
        /// <param name="resources">List of web resources to process.</param>
        /// <param name="resourceType">Web resource types being processed.</param>
        /// <returns>
        /// Transformed list of web resources.
        /// </returns>
        public override IEnumerable<string> ProcessResources(IEnumerable<string> resources, ResourceType resourceType)
        {
            var result = base.ProcessResources(resources, resourceType);

            return ResourceType.HasFlag(resourceType)
                ? result.Distinct() : result;
        }

 public static void GetResourceData(Stream stream, out uint flags, out ResourceType type)
 {
     var rh = new ResourceHeader();
     rh.Read(new BinaryReader(stream));
     flags = rh.Flags;
     type = rh.Type;
 }

		protected NativeObjectSecurity (bool isContainer,
						ResourceType resourceType,
						ExceptionFromErrorCode exceptionFromErrorCode,
						object exceptionContext)
			: this (isContainer, resourceType)
		{
		}

        private static MvcHtmlString RegisterResources(this HtmlHelper helper, SimpleCompressionConfiguration configuration, string[] files, ResourceType resourceType)
        {
            configuration = configuration ?? SimpleCompressionConfiguration.DefaulConfiguration;

            Func<string, string> printFunc = resourceType == ResourceType.Css
                                                 ? (Func<string,string>)TagHelper.PrintCssTag
                                                 : TagHelper.PrintJavascriptTag;

            string tagString = string.Empty;
            if (configuration.Disable)
            {
                foreach (var file in files)
                {
                    tagString += helper.PrintTag(file, printFunc);
                }
            }
            else
            {

                var fileResources = CreateResources(files, configuration);

                var hashCode = fileResources.GetHashCode();
                string extension = resourceType == ResourceType.Css ? ".css" : ".js";
                string fileName = configuration.ClientVersionPrefix + "_" + hashCode + extension;
                string filePath = "~/" + configuration.FolderForCachedResources + fileName;
                ResourceCacheManager.Instance.AddResourcesToCache(fileName, new Tuple<List<FileResource>, SimpleCompressionConfiguration>(fileResources, configuration));
                tagString = helper.PrintTag(filePath, printFunc);
            }
            return new MvcHtmlString(tagString);
        }

 protected override void Start()
 {
     base.Start();
     amountLeft = capacity;
     resourceType = ResourceType.Unknown;
     worldObjectType = WorldObjectType.Resource;
 }

 private void IncResource(ResourceType resource, int amount)
 {
     // make sure we have under the limit
     if (this.resourceLimits [resource] > (this.resources [resource] + amount)) {
         this.resources [resource] += amount;
     }
 }

 public CacheSetting(Guid id, ResourceType resourceType, DateTime? lastRefreshedDateUtc, int cacheValidDurationInSeconds)
 {
     this.Id = id;
     this.ResourceType = resourceType;
     this.LastRefreshedDateUtc = lastRefreshedDateUtc;
     this.CacheValidDurationInSeconds = cacheValidDurationInSeconds;
 }

        public void HandleResource(HttpContextBase httpContext, ResourceType resourceType, string resourceGroupName)
        {
            CompressionType compressionType;
            ProcessedResourceGroupInfo resourceInfo = ProcessResource(httpContext, resourceType, resourceGroupName, out compressionType);

            HandleResource(httpContext, resourceType, compressionType, resourceInfo);
        }

 public AutoDiscoveryResult (Uri ressourceUrl, bool wasCancelled, ResourceType resourceType)
     : this()
 {
   _wasCancelled = wasCancelled;
   _ressourceUrl = ressourceUrl;
   _resourceType = resourceType;
 }

        /// <summary>
        /// Converts the given resource type to a studio resource type string (WorkflowService, Service, Source, ReservedService, or *).
        /// </summary>
        /// <param name="resourceType">The type of the resource to be converted.</param>
        /// <returns>A studio resource type string.</returns>
        public static string ToTypeString(ResourceType resourceType)
        {
            switch(resourceType)
            {
                case ResourceType.Server:
                case ResourceType.DbSource:
                case ResourceType.PluginSource:
                case ResourceType.EmailSource:
                case ResourceType.WebSource:
                case ResourceType.ServerSource:
                case ResourceType.SharepointServerSource:
                case ResourceType.OauthSource:
                    return TypeSource;

                case ResourceType.PluginService:
                case ResourceType.DbService:
                case ResourceType.WebService:
                    return TypeService;

                case ResourceType.WorkflowService:
                    return TypeWorkflowService;

                case ResourceType.ReservedService:
                    return TypeReservedService;
                default:
                    return TypeWildcard;
            }
        }

 public static void ClearRegistrations(ResourceType resourceType)
 {
     if (_transformerRegistrations.ContainsKey(resourceType))
     {
         _transformerRegistrations[resourceType].Clear();
     }
 }

		internal NativeObjectSecurity (CommonSecurityDescriptor securityDescriptor, ResourceType resourceType)
			: base (securityDescriptor)
		{
#if !MOBILE			
			resource_type = resourceType;
#endif
		}

 public ResourceStat(Resource resource, string info = "")
 {
     Type = resource.ResourceType;
     Version = resource.Version;
     Count = 1;
     Info = info;
 }

 public DynamicallyCompiledIndividualResourceHandler(string physicalPathToResource,
     ResourceType resourceType,
     ContentFilterPipeline contentFilterPipeline,
     ContentFilterContext contentFilterContext)
     : this(physicalPathToResource, resourceType, contentFilterPipeline, contentFilterContext, new FileAccessWrapper())
 {
 }