Asset.cs

// Copyright (C) 2021-2024 Steffen Itterheim
// Refer to included LICENSE file for terms and conditions.
 
using System;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using UnityEditor;
using Object = UnityEngine.Object;
 
namespace CodeSmileEditor
{
    public sealed partial class Asset
    {
        private Path m_AssetPath;
        private Object m_MainObject;
 
        public static implicit operator Object(Asset asset) => asset != null ? asset.MainObject : null;
 
        public static implicit operator Asset(Object asset) => asset != null ? new Asset(asset) : null;
 
        public static implicit operator Asset(Path path) => path != null ? new Asset(path) : null;
 
        public static implicit operator Asset(String path) => (Path)path; // implicit forward to Asset(Path)
 
        public static implicit operator Asset(GUID guid) => guid.Empty() == false ? new Asset(guid) : null;
 
        [ExcludeFromCodeCoverage] private Asset() {} // disallow parameterless ctor
 
        public Asset(Byte[] contents, Path path, Boolean overwriteExisting = false)
        {
            ThrowIf.ArgumentIsNull(contents, nameof(contents));
            ThrowIf.ArgumentIsNull(path, nameof(path));
 
            path = Path.UniquifyAsNeeded(path, overwriteExisting);
            var asset = File.CreateInternal(contents, path);
            InitWithMainObject(asset);
        }
 
        public Asset(String contents, Path path, Boolean overwriteExisting = false)
        {
            ThrowIf.ArgumentIsNull(contents, nameof(contents));
            ThrowIf.ArgumentIsNull(path, nameof(path));
 
            path = Path.UniquifyAsNeeded(path, overwriteExisting);
            var asset = File.CreateInternal(contents, path);
            InitWithMainObject(asset);
        }
 
        public Asset(Object asset, Path path, Boolean overwriteExisting = false)
        {
            ThrowIf.ArgumentIsNull(asset, nameof(asset));
            ThrowIf.ArgumentIsNull(path, nameof(path));
            ThrowIf.AlreadyAnAsset(asset);
 
            path = Path.UniquifyAsNeeded(path, overwriteExisting);
            File.CreateInternal(asset, path);
            InitWithMainObject(asset);
        }
 
        public Asset(Path path) => InitWithPath(path);
 
        public Asset(GUID assetGuid) => InitWithGuid(assetGuid);
 
        public Asset(Object asset) => InitWithMainObject(asset);
 
        public T GetMain<T>() where T : Object => m_MainObject as T;
 
        public void Save() => File.Save(m_MainObject);
 
        public void ForceSave() => File.ForceSave(m_MainObject);
 
        public Asset SaveAs(Path path) => File.Copy(m_AssetPath, path) ? new Asset(path) : null;
 
        public Asset SaveAsNew(Path path)
        {
            ThrowIf.ArgumentIsNull(path, nameof(path));
 
            return SaveAs(path.UniqueFilePath);
        }
 
        public Asset Duplicate() => SaveAsNew(m_AssetPath);
 
        public void SetDirty() => EditorUtility.SetDirty(m_MainObject);
 
        // NOTE: there is no public Import() method needed since the main object is guaranteed to be imported
        [ExcludeFromCodeCoverage] // private, not used
        private void Import() {}
 
        // Private on purpose: the main object is automatically loaded when instantiating an Asset class.
        private T LoadMain<T>() where T : Object => m_AssetPath != null ? (T)(m_MainObject = File.Load<T>(m_AssetPath)) : null;
 
        public T Load<T>() where T : Object => File.Load<T>(m_AssetPath);
 
        public Boolean CanMove(Path destinationPath) => File.CanMove(m_AssetPath, destinationPath);
 
        public Boolean Move(Path destinationPath)
        {
            if (File.Move(m_AssetPath, destinationPath))
            {
                SetAssetPathFromObject();
                return true;
            }
 
            return false;
        }
 
        public Boolean Rename(String newFileName)
        {
            if (File.Rename(m_AssetPath, newFileName))
            {
                SetAssetPathFromObject();
                return true;
            }
 
            return false;
        }
 
        [ExcludeFromCodeCoverage] // simple relay
        public Boolean CanOpenInEditor() => File.CanOpenInEditor(m_MainObject);
 
        [ExcludeFromCodeCoverage] // cannot be tested
        public void OpenExternal(Int32 lineNumber = -1, Int32 columnNumber = -1) => File.OpenExternal(m_MainObject, lineNumber, columnNumber);
 
        public Object Delete()
        {
            var mainObject = m_MainObject;
            if (File.Delete(m_AssetPath))
                InvalidateInstance();
 
            return mainObject;
        }
 
        public Object Trash()
        {
            var mainObject = m_MainObject;
            if (File.Trash(m_AssetPath))
                InvalidateInstance();
 
            return mainObject;
        }
 
        [ExcludeFromCodeCoverage] // simple relay
        public void SetLabels(String[] labels) => Label.SetAll(m_MainObject, labels);
 
        public void ClearLabels() => Label.ClearAll(m_MainObject);
 
        public void RemoveLabel(String label) => Label.Remove(m_MainObject, label);
 
        public void AddLabel(String label) => Label.Add(m_MainObject, label);
 
        public void AddLabels(String[] labels) => Label.Add(m_MainObject, labels);
 
        [ExcludeFromCodeCoverage] // simple relay
        public void ExportPackage(String packagePath, ExportPackageOptions options = ExportPackageOptions.Default) =>
            Package.Export(m_AssetPath, packagePath, options);
 
        public void AddSubAsset(Object instance) => SubAsset.Add(instance, m_MainObject);
 
        public void RemoveSubAsset(Object subAsset) => SubAsset.Remove(subAsset);
 
        private void InvalidateInstance()
        {
            m_AssetPath = null;
            m_MainObject = null;
        }
 
        private void SetAssetPathFromObject() => m_AssetPath = Path.Get(m_MainObject);
 
        private void InitWithPath(Path path)
        {
            ThrowIf.ArgumentIsNull(path, nameof(path));
            ThrowIf.DoesNotExistInFileSystem(path);
 
            m_AssetPath = path;
            m_MainObject = Status.IsImported(path) ? LoadMain<Object>() : File.ImportAndLoad<Object>(path);
 
            ThrowIf.AssetLoadReturnedNull(m_MainObject, m_AssetPath);
        }
 
        private void InitWithMainObject(Object mainObject)
        {
            ThrowIf.ArgumentIsNull(mainObject, nameof(mainObject));
            ThrowIf.NotInDatabase(mainObject);
 
            m_MainObject = mainObject;
            m_AssetPath = Path.Get(mainObject);
        }
 
        private void InitWithGuid(GUID guid)
        {
            ThrowIf.NotAnAssetGuid(guid);
 
            InitWithPath(Path.Get(guid));
        }
    }
}