/// <summary> /// Initializes a new instance of the <see cref="Property"/> class. /// </summary> /// <param name="name">The name.</param> /// <param name="value">The value.</param> /// <param name="owner">The owner.</param> internal Property( string name, object value, PropertyStorage owner ) { _id = Marshal.StringToCoTaskMemUni( name ); _name = name; _propValue = value; _owner = owner; }
/// <summary> /// Initializes a new instance of the <see cref="Property"/> class. /// </summary> /// <param name="id">The id.</param> /// <param name="name">The name.</param> /// <param name="value">The value.</param> /// <param name="owner">The owner.</param> internal Property( IntPtr id, string name, object value, PropertyStorage owner ) { _id = id; _name = name; _propValue = value; _owner = owner; }
/** * Writes outStream the property sets * * @exception IOException */ private void writePropertySets() { byte[] propertySetStorage = new byte[BIG_BLOCK_SIZE * numRootEntryBlocks]; int pos = 0; int[] mappings = null; // Build up the mappings array if (additionalPropertySets != null) { mappings = new int[numPropertySets]; // Map the standard ones to the first four for (int i = 0; i < STANDARD_PROPERTY_SETS.Length; i++) { if (!standardPropertySets.ContainsKey(STANDARD_PROPERTY_SETS[i])) { //logger.warn("Standard property set " + STANDARD_PROPERTY_SETS[i] + // " not present in source file"); } else { ReadPropertyStorage rps = standardPropertySets[STANDARD_PROPERTY_SETS[i]]; mappings[rps.number] = i; } } // Now go through the original ones int newMapping = STANDARD_PROPERTY_SETS.Length; foreach (ReadPropertyStorage rps in additionalPropertySets) { mappings[rps.number] = newMapping; newMapping++; } } int child = 0; int previous = 0; int next = 0; // Compute the size of the root property set int size = 0; if (additionalPropertySets != null) { // Workbook size += getBigBlocksRequired(requiredSize) * BIG_BLOCK_SIZE; // The two information blocks size += getBigBlocksRequired(SMALL_BLOCK_THRESHOLD) * BIG_BLOCK_SIZE; size += getBigBlocksRequired(SMALL_BLOCK_THRESHOLD) * BIG_BLOCK_SIZE; // Additional property sets foreach (ReadPropertyStorage rps in additionalPropertySets) { if (rps.propertyStorage.type != 1) { if (rps.propertyStorage.size >= SMALL_BLOCK_THRESHOLD) size += getBigBlocksRequired(rps.propertyStorage.size) * BIG_BLOCK_SIZE; else size += getSmallBlocksRequired(rps.propertyStorage.size) * SMALL_BLOCK_SIZE; } } } // Set the root entry property set PropertyStorage ps = new PropertyStorage(ROOT_ENTRY_NAME); ps.setType(5); ps.setStartBlock(sbdStartBlock); ps.setSize(size); ps.setPrevious(-1); ps.setNext(-1); ps.setColour(0); child = 1; if (additionalPropertySets != null) { ReadPropertyStorage rps = standardPropertySets[ROOT_ENTRY_NAME]; child = mappings[rps.propertyStorage.child]; } ps.setChild(child); System.Array.Copy(ps.data, 0, propertySetStorage, pos, PROPERTY_STORAGE_BLOCK_SIZE); pos += PROPERTY_STORAGE_BLOCK_SIZE; // Set the workbook property set ps = new PropertyStorage(WORKBOOK_NAME); ps.setType(2); ps.setStartBlock(excelDataStartBlock); // start the excel data after immediately after this block ps.setSize(requiredSize); // always use a big block stream - none of that messing around // with small blocks previous = 3; next = -1; if (additionalPropertySets != null) { ReadPropertyStorage rps = standardPropertySets[WORKBOOK_NAME]; previous = rps.propertyStorage.previous != -1 ? mappings[rps.propertyStorage.previous] : -1; next = rps.propertyStorage.next != -1 ? mappings[rps.propertyStorage.next] : -1; } ps.setPrevious(previous); ps.setNext(next); ps.setChild(-1); System.Array.Copy(ps.data, 0, propertySetStorage, pos, PROPERTY_STORAGE_BLOCK_SIZE); pos += PROPERTY_STORAGE_BLOCK_SIZE; // Set the summary information ps = new PropertyStorage(SUMMARY_INFORMATION_NAME); ps.setType(2); ps.setStartBlock(excelDataStartBlock + excelDataBlocks); ps.setSize(SMALL_BLOCK_THRESHOLD); previous = 1; next = 3; if (additionalPropertySets != null) { if (standardPropertySets.ContainsKey(SUMMARY_INFORMATION_NAME)) { ReadPropertyStorage rps = standardPropertySets[SUMMARY_INFORMATION_NAME]; previous = rps.propertyStorage.previous != -1 ? mappings[rps.propertyStorage.previous] : -1; next = rps.propertyStorage.next != -1 ? mappings[rps.propertyStorage.next] : -1; } } ps.setPrevious(previous); ps.setNext(next); ps.setChild(-1); System.Array.Copy(ps.data, 0, propertySetStorage, pos, PROPERTY_STORAGE_BLOCK_SIZE); pos += PROPERTY_STORAGE_BLOCK_SIZE; // Set the document summary information ps = new PropertyStorage(DOCUMENT_SUMMARY_INFORMATION_NAME); ps.setType(2); ps.setStartBlock(excelDataStartBlock + excelDataBlocks + 8); ps.setSize(SMALL_BLOCK_THRESHOLD); ps.setPrevious(-1); ps.setNext(-1); ps.setChild(-1); System.Array.Copy(ps.data, 0, propertySetStorage, pos, PROPERTY_STORAGE_BLOCK_SIZE); pos += PROPERTY_STORAGE_BLOCK_SIZE; // Write outStream the additional property sets if (additionalPropertySets == null) { outStream.Write(propertySetStorage,0,propertySetStorage.Length); return; } int bigBlock = excelDataStartBlock + excelDataBlocks + 16; int smallBlock = 0; foreach (ReadPropertyStorage rps in additionalPropertySets) { int block = rps.data.Length > SMALL_BLOCK_THRESHOLD ? bigBlock : smallBlock; ps = new PropertyStorage(rps.propertyStorage.name); ps.setType(rps.propertyStorage.type); ps.setStartBlock(block); ps.setSize(rps.propertyStorage.size); // ps.setColour(rps.propertyStorage.colour); previous = rps.propertyStorage.previous != -1 ? mappings[rps.propertyStorage.previous] : -1; next = rps.propertyStorage.next != -1 ? mappings[rps.propertyStorage.next] : -1; child = rps.propertyStorage.child != -1 ? mappings[rps.propertyStorage.child] : -1; ps.setPrevious(previous); ps.setNext(next); ps.setChild(child); System.Array.Copy(ps.data, 0, propertySetStorage, pos, PROPERTY_STORAGE_BLOCK_SIZE); pos += PROPERTY_STORAGE_BLOCK_SIZE; if (rps.data.Length > SMALL_BLOCK_THRESHOLD) bigBlock += getBigBlocksRequired(rps.data.Length); else smallBlock += getSmallBlocksRequired(rps.data.Length); } outStream.Write(propertySetStorage,0,propertySetStorage.Length); }
public ReadPropertyStorage(PropertyStorage ps, byte[] d, int n) { propertyStorage = ps; data = d; number = n; }
public void Dispose() { Events.Fire("OnDispose"); Dependencies = null; Filename = null; Icons = null; Info = null; ItemTemplates = null; ProjectTemplates = null; Properties = null; _engine = null; }
public void Dispose() { Dependencies = null; Filename = null; Highlightings = null; Icons = null; Info = null; ItemTemplates = null; Language = null; ProjectTemplates = null; Properties = null; _engine = null; }
/** * Build up the resultant stream using the small blocks * @param ps the property storage * @return the data * @exception BiffException */ private byte[] getSmallBlockStream(PropertyStorage ps) { byte[] rootdata = readData(rootEntryPropertyStorage.startBlock); byte[] sbdata = new byte[0]; int block = ps.startBlock; int pos = 0; int blockCount = 0; for (; blockCount <= smallBlockChain.Length && block != -2; blockCount++) { // grow the array byte[] olddata = sbdata; sbdata = new byte[olddata.Length + SMALL_BLOCK_SIZE]; System.Array.Copy(olddata,0,sbdata,0,olddata.Length); // Copy in the new data pos = block * SMALL_BLOCK_SIZE; System.Array.Copy(rootdata,pos,sbdata, olddata.Length,SMALL_BLOCK_SIZE); block = smallBlockChain[block]; if (block == -1) { //logger.warn("Incorrect terminator for small block stream " + ps.name); block = -2; // kludge to force the loop termination } } if (blockCount > smallBlockChain.Length) { // Attempted to read more blocks than the block chain contains entries // for. This indicates a loop in the chain throw new BiffException(BiffException.corruptFileFormat); } return sbdata; }
/** * Reads all the property sets */ private void readPropertySets() { int offset = 0; byte[] d = null; while (offset < rootEntry.Length) { d = new byte[PROPERTY_STORAGE_BLOCK_SIZE]; System.Array.Copy(rootEntry,offset,d,0,d.Length); PropertyStorage ps = new PropertyStorage(d); // sometimes the MAC Operating system leaves some property storage // names blank. Contributed by Jacky if (ps.name == null || ps.name.Length == 0) { if (ps.type == ROOT_ENTRY_PS_TYPE) { ps.name = ROOT_ENTRY_NAME; //logger.warn("Property storage name for " + ps.type + // " is empty - setting to " + ROOT_ENTRY_NAME); } else { if (ps.size != 0) { //logger.warn("Property storage type " + ps.type + // " is non-empty and has no associated name"); } } } propertySets.Add(ps); if (System.String.Compare(ps.name,ROOT_ENTRY_NAME,true) == 0) rootEntryPropertyStorage = ps; offset += PROPERTY_STORAGE_BLOCK_SIZE; } if (rootEntryPropertyStorage == null) rootEntryPropertyStorage = (PropertyStorage)propertySets[0]; }
/** * Build up the resultant stream using the big blocks * * @param ps the property storage * @return the big block stream */ private byte[] getBigBlockStream(PropertyStorage ps) { int numBlocks = ps.size / BIG_BLOCK_SIZE; if (ps.size % BIG_BLOCK_SIZE != 0) { numBlocks++; } byte[] streamData = new byte[numBlocks * BIG_BLOCK_SIZE]; int block = ps.startBlock; int count = 0; int pos = 0; while (block != -2 && count < numBlocks) { pos = (block + 1) * BIG_BLOCK_SIZE; System.Array.Copy(data,pos,streamData, count * BIG_BLOCK_SIZE,BIG_BLOCK_SIZE); count++; block = bigBlockChain[block]; } if (block != -2 && count == numBlocks) { //logger.warn("Property storage size inconsistent with block chain."); } return streamData; }
/** * Recursively searches the property storages in hierarchy order * for the appropriate name. */ private PropertyStorage findPropertyStorage(string name, PropertyStorage ps) { if (ps.child == -1) { return null; } // Get the child PropertyStorage child = getPropertyStorage(ps.child); if (System.String.Compare(child.name,name) == 0) return child; // Find the previous property storages on the same level PropertyStorage prev = child; while (prev.previous != -1) { prev = getPropertyStorage(prev.previous); if (System.String.Compare(prev.name,name) == 0) return prev; } // Find the next property storages on the same level PropertyStorage next = child; while (next.next != -1) { next = getPropertyStorage(next.next); if (System.String.Compare(next.name,name) == 0) return next; } return findPropertyStorage(name,child); }
/// <summary> /// Creates a <see cref="RouteValueDictionary"/> initialized with the specified <paramref name="values"/>. /// </summary> /// <param name="values">An object to initialize the dictionary. The value can be of type /// <see cref="IDictionary{TKey, TValue}"/> or <see cref="IReadOnlyDictionary{TKey, TValue}"/> /// or an object with public properties as key-value pairs. /// </param> /// <remarks> /// If the value is a dictionary or other <see cref="IEnumerable{T}"/> of <see cref="KeyValuePair{String, Object}"/>, /// then its entries are copied. Otherwise the object is interpreted as a set of key-value pairs where the /// property names are keys, and property values are the values, and copied into the dictionary. /// Only public instance non-index properties are considered. /// </remarks> public RouteValueDictionary(object values) { if (values is RouteValueDictionary dictionary) { if (dictionary._propertyStorage != null) { // PropertyStorage is immutable so we can just copy it. _propertyStorage = dictionary._propertyStorage; _count = dictionary._count; return; } var count = dictionary._count; if (count > 0) { var other = dictionary._arrayStorage; var storage = new KeyValuePair <string, object> [count]; Array.Copy(other, 0, storage, 0, count); _arrayStorage = storage; _count = count; } else { _arrayStorage = Array.Empty <KeyValuePair <string, object> >(); } return; } if (values is IEnumerable <KeyValuePair <string, object> > keyValueEnumerable) { _arrayStorage = Array.Empty <KeyValuePair <string, object> >(); foreach (var kvp in keyValueEnumerable) { Add(kvp.Key, kvp.Value); } return; } if (values is IEnumerable <KeyValuePair <string, string> > stringValueEnumerable) { _arrayStorage = Array.Empty <KeyValuePair <string, object> >(); foreach (var kvp in stringValueEnumerable) { Add(kvp.Key, kvp.Value); } return; } if (values != null) { var storage = new PropertyStorage(values); _propertyStorage = storage; _count = storage.Properties.Length; } else { _arrayStorage = Array.Empty <KeyValuePair <string, object> >(); } }
public PropertyStorage(PropertyStorage propertyStorage) { _value = propertyStorage._value; _properties = propertyStorage._properties; }
set => SetProperty(ref PropertyStorage, value);