public GraphFSError_MetadataObjectNotFound(ObjectLocation myObjectLocation, String myObjectStream, String myObjectEdition)
 {
     ObjectLocation  = myObjectLocation;
     ObjectStream    = myObjectStream;
     ObjectEdition   = myObjectEdition;
     Message         = String.Format("MetadataObject at location '{0}{1}{0}{2}{0}{3}' not found!", FSPathConstants.PathDelimiter, ObjectLocation, ObjectStream, ObjectEdition);
 }

 public GraphFSError_CouldNotSetMetadata(ObjectLocation myObjectLocation, String myObjectStream, String myObjectEdition)
 {
     ObjectLocation = myObjectLocation;
     ObjectStream   = myObjectStream;
     ObjectEdition  = myObjectEdition;
     Message        = String.Format("Could not set metadata at location '{1}{0}{2}{0}{3}'!", FSPathConstants.PathDelimiter, ObjectLocation, ObjectStream, ObjectEdition);
 }

        public byte Read(ObjectLocation objLocation)
        {
            byte returnValue = (byte) new Random(objLocation.Index + objLocation.ObjectPath.Length + (int) objLocation.Type).Next(256);
            //byte returnValue = 0;
            switch (objLocation.Type)
            {
                //open the appropriate type of object and read the data inside it
                case ObjectType.FileWithHeader:

                    break;
                case ObjectType.Array:

                    break;
                case ObjectType.LinkedList:

                    break;
                case ObjectType.HashTable:

                    break;
                case ObjectType.Heap:

                    break;
            }
            return returnValue;
        }

        public void ObjServiceMove(String sourceObjectPathString,
                                   String targetLocPathString,
                                   String sourceLocPathString)
        {
            // identify the object to move
            ObjectPath objPath = new ObjectPath(sourceObjectPathString);
            ObjectIdentity docToCopy = new ObjectIdentity();
            docToCopy.Value = objPath;
            docToCopy.RepositoryName = DefaultRepository;

            // identify the folder to move from
            ObjectPath fromFolderPath = new ObjectPath();
            fromFolderPath.Path = sourceLocPathString;
            ObjectIdentity fromFolderIdentity = new ObjectIdentity();
            fromFolderIdentity.Value = fromFolderPath;
            fromFolderIdentity.RepositoryName = DefaultRepository;
            ObjectLocation fromLocation = new ObjectLocation();
            fromLocation.Identity = fromFolderIdentity;

            // identify the folder to move to
            ObjectPath folderPath = new ObjectPath(targetLocPathString);
            ObjectIdentity toFolderIdentity = new ObjectIdentity();
            toFolderIdentity.Value = folderPath;
            toFolderIdentity.RepositoryName = DefaultRepository;
            ObjectLocation toLocation = new ObjectLocation();
            toLocation.Identity = toFolderIdentity;

            OperationOptions operationOptions = null;
            objectService.Move(new ObjectIdentitySet(docToCopy),
                               fromLocation,
                               toLocation,
                               new DataPackage(),
                               operationOptions);
        }

 public GraphFSError_NoObjectRevisionsFound(ObjectLocation myObjectLocation, String myObjectStream, String myObjectEdition)
 {
     ObjectLocation  = myObjectLocation;
     ObjectStream    = myObjectStream;
     ObjectEdition   = myObjectEdition;
     Message         = String.Format("No object revisions found at location '{1}{0}{2}{0}{3}'!", FSPathConstants.PathDelimiter, ObjectLocation, ObjectStream, ObjectEdition);
 }

        public override Exceptional Execute(AGraphDSSharp myAGraphDSSharp, ref String myCurrentPath, Dictionary<String, List<AbstractCLIOption>> myOptions, String myInputString)
        {
            if (myAGraphDSSharp == null)
                return new Exceptional(new GraphDSError("myAGraphDSSharp must not be null!"));

            ObjectLocation _DirectoryObjectLocation = null;

            try
            {
                _DirectoryObjectLocation = new ObjectLocation(ObjectLocation.ParseString(myCurrentPath), myOptions.ElementAt(1).Value[0].Option);
            }
            catch (Exception e)
            {
                WriteLine(e.Message);
                return Exceptional.OK;
            }

            try
            {
                myAGraphDSSharp.CreateDirectoryObject(_DirectoryObjectLocation);
            }

            catch (Exception e)
            {
                WriteLine(e.Message);
            }

            return Exceptional.OK;
        }

        public override Exceptional Execute(AGraphDSSharp myAGraphDSSharp, ref String myCurrentPath, Dictionary<String, List<AbstractCLIOption>> myOptions, String myInputString)
        {
            if (myAGraphDSSharp == null)
                return new Exceptional(new GraphDSError("myAGraphDSSharp must not be null!"));

            var _Content        = myOptions.ElementAt(1).Value[0].Option;
            var _FileLocation   = new ObjectLocation(ObjectLocation.ParseString(myCurrentPath), myOptions.ElementAt(2).Value[0].Option);

            if (myAGraphDSSharp.ObjectExists(_FileLocation).Value != Trinary.TRUE)
            {

                try
                {
                    AFSObject _FileObject = new FileObject() { ObjectLocation = _FileLocation, ObjectData = Encoding.UTF8.GetBytes(_Content)};
                    myAGraphDSSharp.StoreFSObject(_FileObject, true);
                }
                catch (Exception e)
                {
                    WriteLine(e.Message);
                }

            }

            else
            {

                if (myAGraphDSSharp.ObjectStreamExists(_FileLocation, FSConstants.INLINEDATA).Value)
                {

                }

            }

            return Exceptional.OK;
        }

        private void CD_private(IGraphFSSession myIGraphFSSession, ref String myCurrentPath, String myParameter)
        {
            var _DirectoryObjectLocation = new ObjectLocation(ObjectLocation.ParseString(myCurrentPath), myParameter);

            try
            {

                if ((myIGraphFSSession).ObjectStreamExists(_DirectoryObjectLocation, FSConstants.DIRECTORYSTREAM).Value ||
                    (myIGraphFSSession).ObjectStreamExists(_DirectoryObjectLocation, FSConstants.VIRTUALDIRECTORY).Value)
                {

                    if (myCurrentPath.Equals(FSPathConstants.PathDelimiter) && _DirectoryObjectLocation.Equals("/.."))
                        myCurrentPath = FSPathConstants.PathDelimiter;

                    else
                        myCurrentPath = SimplifyObjectLocation(_DirectoryObjectLocation.ToString());

                }
                else
                    WriteLine("Sorry, this directory does not exist!");

            }

            catch (Exception e)
            {
                WriteLine(e.Message);
                WriteLine(e.StackTrace);
            }
        }

 public NObjectStored(ObjectLocation myObjectLocation, String myObjectStream, String myObjectEdition, ObjectRevisionID myObjectRevisionID)
 {
     ObjectLocation      = myObjectLocation;
     ObjectStream        = myObjectStream;
     ObjectEdition       = myObjectEdition;
     ObjectRevisionID    = myObjectRevisionID;
 }

 public GraphFSError_ObjectEditionNotFound(ObjectLocation myObjectLocation, String myObjectStream, String myObjectEdition)
 {
     ObjectLocation  = myObjectLocation;
     ObjectStream    = myObjectStream;
     ObjectEdition   = myObjectEdition;
     Message         = String.Format("Object edition '{0}' at location '{1}{2}{3}' not found!", ObjectEdition, ObjectLocation, FSPathConstants.PathDelimiter, ObjectStream);
 }

        /// <summary>
        /// The constructor for creating a new AccessControlObject with certain rights.
        /// </summary>
        /// <param name="myObjectLocation">the location of the AccessControlObject (constisting of the ObjectPath and ObjectName) within the file system</param>
        /// <param name="myDefaultRule">This property defines the priority of allowing and denying.</param>
        /// <param name="myAllowACL">The dictionary of rights with corresponding ACLs that allow the access to an object in the GraphFS.</param>
        /// <param name="myDenyACL">The dictionary of rights with corresponding ACLs that denies the access to an object in the GraphFS.</param>
        /// <param name="myNotificationHandling">the NotificationHandling bitfield</param>
        public AccessControlObject(ObjectLocation myObjectLocation, DefaultRuleTypes myDefaultRule, Dictionary<RightUUID, HashSet<EntityUUID>> myAllowACL, Dictionary<RightUUID, HashSet<EntityUUID>> myDenyACL, NHAccessControlObject myNotificationHandling)
        {
            if (myAllowACL == null)
                throw new ArgumentNullException("Invalid AllowACL!");

            if (myDenyACL == null)
                throw new ArgumentNullException("Invalid DenyACL!");

            _AllowACL               = myAllowACL;
            _DenyACL                = myDenyACL;
            _DefaultRule            = myDefaultRule;
            _NotificationHandling   = myNotificationHandling;

            #region calc estimated size

            #region AllowACL

            _estimatedSize += CalcACLSize(myAllowACL);

            #endregion

            #region DenyACL

            _estimatedSize += CalcACLSize(myDenyACL);

            #endregion

            _estimatedSize += EstimatedSizeConstants.EnumByte + EstimatedSizeConstants.EnumUInt64 + GetClassDefaultSize();

            #endregion
        }

 public GraphFSError_AllObjectCopiesFailed(ObjectLocation myObjectLocation, String myObjectStream, String myObjectEdition, ObjectRevisionID myRevisionID)
 {
     ObjectLocation  = myObjectLocation;
     ObjectStream    = myObjectStream;
     ObjectEdition   = myObjectEdition;
     RevisionID      = myRevisionID;
     Message         = String.Format("All object copies at location '{1}{0}{2}{0}{3}{0}{4}' failed!", FSPathConstants.PathDelimiter, ObjectLocation, ObjectStream, ObjectEdition, RevisionID);
 }

 /// <summary>
 /// The constructor.
 /// </summary>
 /// <param name="myIGraphDBSession">The filesystem where the information is stored.</param>
 /// <param name="DatabaseRootPath">The database root path.</param>
 public DBTypeManager(IGraphFSSession myIGraphFS, ObjectLocation myDatabaseRootPath, EntityUUID myUserID, Dictionary<String, ADBSettingsBase> myDBSettings, DBContext dbContext)
 {
     _DBContext = dbContext;
     _UserID = myUserID;
     _DatabaseRootPath                               = myDatabaseRootPath;
     _IGraphFSSession                                = myIGraphFS;
     _ObjectLocationsOfAllUserDefinedDatabaseTypes   = LoadListOfTypeLocations(myDatabaseRootPath);
 }

 public GraphFSError_CouldNotOverwriteRevision(ObjectLocation myObjectLocation, String myObjectStream, String myObjectEdition, ObjectRevisionID myObjectRevisionID)
 {
     ObjectLocation      = myObjectLocation;
     ObjectStream        = myObjectStream;
     ObjectEdition       = myObjectEdition;
     ObjectRevisionID    = myObjectRevisionID;
     Message             = String.Format("Could not overwrite object revision '{1}{0}{2}{0}{3}{0}{4}'!", FSPathConstants.PathDelimiter, ObjectLocation, ObjectStream, ObjectEdition, ObjectRevisionID);
 }

        public IGraphFS GetChildFS(ObjectLocation myObjectLocation)
        {
            IGraphFS _ChildFS = null;

            if (_ChildFSLookuptable.TryGetValue(myObjectLocation, out _ChildFS))
                return _ChildFS;

            return null;
        }

        /// <summary>
        /// The constructor.
        /// </summary>
        /// <param name="myIGraphDBSession">The filesystem where the information is stored.</param>
        /// <param name="DatabaseRootPath">The database root path.</param>
        public DBTypeManager(IGraphFSSession myIGraphFS, ObjectLocation myDatabaseRootPath, EntityUUID myUserID, Dictionary<String, ADBSettingsBase> myDBSettings, DBContext dbContext)
        {
            _DBContext = dbContext;
            _UserID = myUserID;
            _DatabaseRootPath                               = myDatabaseRootPath;
            _IGraphFSSession                                = myIGraphFS;
            _ObjectLocationsOfAllUserDefinedDatabaseTypes   = LoadListOfTypeLocations(myDatabaseRootPath);

            dbContext.GraphAppSettings.Subscribe<ObjectsDirectoryShardsSetting>(GraphSettingChanged);
        }

        /// <summary>
        /// A constructor used for fast deserializing
        /// </summary>
        /// <param name="myObjectLocation">the location of this object (ObjectPath and ObjectName) of the requested file within the file system</param>
        /// <param name="mySerializedData">A bunch of bytes[] containing the serialized FileObject</param>
        public FileObject(ObjectLocation myObjectLocation, Byte[] mySerializedData, IIntegrityCheck myIntegrityCheckAlgorithm, ISymmetricEncryption myEncryptionAlgorithm)
        {
            if (myObjectLocation == null || myObjectLocation.Length == 0)
                throw new ArgumentNullException("Invalid myObjectLocation!");

            if (mySerializedData == null || mySerializedData.Length == 0)
                throw new ArgumentNullException("mySerializedData must not be null or its length be zero!");

            Deserialize(mySerializedData, myIntegrityCheckAlgorithm, myEncryptionAlgorithm, false);
            _isNew = false;
        }

        public DBSettingsManager(Dictionary<String, ADBSettingsBase> myReflectorSettings, Dictionary<String, ADBSettingsBase> myDBSettings, IGraphFSSession myIGraphFS, ObjectLocation mySettingsLocation)
        {
            _IGraphFSSession    = myIGraphFS;
            _DBSettingsLocation = mySettingsLocation;

            AllSettingsByName = new Dictionary<string, ADBSettingsBase>();
            AllSettingsByUUID = new Dictionary<UUID, ADBSettingsBase>();

            AddSettings(myReflectorSettings);
            AddSettings(myDBSettings);
        }

        /// <summary>
        /// The constructor for creating a new AccessControlObject with certain rights.
        /// </summary>
        /// <param name="myObjectLocation">the location of the AccessControlObject (constisting of the ObjectPath and ObjectName) within the file system</param>
        /// <param name="myDefaultRule">This property defines the priority of allowing and denying.</param>
        /// <param name="myAllowACL">The dictionary of rights with corresponding ACLs that allow the access to an object in the GraphFS.</param>
        /// <param name="myDenyACL">The dictionary of rights with corresponding ACLs that denies the access to an object in the GraphFS.</param>
        /// <param name="myNotificationHandling">the NotificationHandling bitfield</param>
        public AccessControlObject(ObjectLocation myObjectLocation, DefaultRuleTypes myDefaultRule, Dictionary<RightUUID, HashSet<EntityUUID>> myAllowACL, Dictionary<RightUUID, HashSet<EntityUUID>> myDenyACL, NHAccessControlObject myNotificationHandling)
        {
            if (myAllowACL == null)
                throw new ArgumentNullException("Invalid AllowACL!");

            if (myDenyACL == null)
                throw new ArgumentNullException("Invalid DenyACL!");

            _AllowACL               = myAllowACL;
            _DenyACL                = myDenyACL;
            _DefaultRule            = myDefaultRule;
            _NotificationHandling   = myNotificationHandling;
        }

        public GraphFSError_CreateDirectoryFailed(ObjectLocation myObjectLocation, String myMessage = null)
        {
            ObjectLocation = myObjectLocation;

            if (myMessage != null)
            {
                Message = String.Format("Creating a directory at location '{0}' failed because: {1}", ObjectLocation, myMessage);
            }
            else
            {
                Message = String.Format("Creating a directory at location '{0}' failed!", ObjectLocation);
            }
        }