public Storage(StorageType type) : base() { localFolder = ApplicationData.Current.LocalFolder; path = type == StorageType.SECURE ? MPIN_STORAGE : USER_STORAGE; this.Data = string.Empty; }
/// <summary> /// Gets total number of images in a presentation from a 3rd party storage /// </summary> /// <param name="storageType"></param> /// <param name="storageName">Name of the storage</param> /// <param name="folderName">In case of Amazon S3 storage the folder's path starts with Amazon S3 Bucket name.</param> /// <returns>Total number of images</returns> public int GetImageCount(StorageType storageType, string storageName, string folderName) { //build URI to get image count StringBuilder strURI = new StringBuilder(Product.BaseProductUri + "/slides/" + FileName + "/images" + (string.IsNullOrEmpty(folderName) ? "" : "?folder=" + folderName)); switch (storageType) { case StorageType.AmazonS3: strURI.Append("&storage=" + storageName); break; } string signedURI = Utils.Sign(strURI.ToString()); Stream responseStream = Utils.ProcessCommand(signedURI, "GET"); StreamReader reader = new StreamReader(responseStream); string strJSON = reader.ReadToEnd(); //Parse the json string to JObject JObject parsedJSON = JObject.Parse(strJSON); //Deserializes the JSON to a object. ImagesResponse imagesResponse = JsonConvert.DeserializeObject<ImagesResponse>(parsedJSON.ToString()); return imagesResponse.Images.List.Count; }
internal int SetBytes(long fieldOffset, byte[] buffer, int bufferOffset, int length) { int dstOffset = (int) fieldOffset; if (this.IsNull || (StorageType.ByteArray != this._type)) { if (dstOffset != 0) { throw ADP.ArgumentOutOfRange("fieldOffset"); } this._object = new byte[length]; this._type = StorageType.ByteArray; this._isNull = false; this.BytesLength = length; } else { if (dstOffset > this.BytesLength) { throw ADP.ArgumentOutOfRange("fieldOffset"); } if ((dstOffset + length) > this.BytesLength) { int num2 = ((byte[]) this._object).Length; if ((dstOffset + length) > num2) { byte[] dst = new byte[Math.Max((int) (dstOffset + length), (int) (2 * num2))]; Buffer.BlockCopy((byte[]) this._object, 0, dst, 0, (int) this.BytesLength); this._object = dst; } this.BytesLength = dstOffset + length; } } Buffer.BlockCopy(buffer, bufferOffset, (byte[]) this._object, dstOffset, length); return length; }
internal DataExpression(DataTable table, string expression, Type type) { this.dependency = DataTable.zeroColumns; ExpressionParser parser = new ExpressionParser(table); parser.LoadExpression(expression); this.originalExpression = expression; this.expr = null; if (expression != null) { this._storageType = DataStorage.GetStorageType(type); if (this._storageType == StorageType.BigInteger) { throw ExprException.UnsupportedDataType(type); } this._dataType = type; this.expr = parser.Parse(); this.parsed = true; if ((this.expr != null) && (table != null)) { this.Bind(table); } else { this.bound = false; } } }
internal static bool IsSigned(StorageType type) { return(type == StorageType.Int16 || type == StorageType.Int32 || type == StorageType.Int64 || type == StorageType.SByte || IsFloat(type)); }
public Storage LoadStorage(Player player, StorageType type) { string SQL = "SELECT * FROM `inventory` WHERE " + "`playerid` = ?pid AND `storagetype` = ?type"; MySqlCommand cmd = new MySqlCommand(SQL, InventoryDAOConnection); cmd.Parameters.AddWithValue("?pid", player.Id); cmd.Parameters.AddWithValue("?type", type.ToString()); MySqlDataReader LoadStorageReader = cmd.ExecuteReader(); var storage = new Storage { StorageType = StorageType.Inventory }; if (LoadStorageReader.HasRows) { while (LoadStorageReader.Read()) { if (LoadStorageReader.GetInt32(2) != 20000000) { StorageItem item = new StorageItem() { ItemId = LoadStorageReader.GetInt32(2), Amount = LoadStorageReader.GetInt32(3), Color = LoadStorageReader.GetInt32(4), }; storage.Items.Add(LoadStorageReader.GetInt32(5), item); } else { storage.Money = LoadStorageReader.GetInt32(3); } } } LoadStorageReader.Close(); return storage; }
public async Task<AccountConfiguration> CreateOrUpdateAccount(StorageType type) { var newAccount = await _storageService.CreateAccount(type); if (newAccount == null) return null; var existingAccount = _configService.Accounts.SingleOrDefault(_ => _.Type == newAccount.Type && _.Id == newAccount.Id); if (existingAccount == null) // New Account { // ensure account's name is unique var i = 1; var name = newAccount.Name; while ( _configService.Accounts.Any( _ => _.Type == newAccount.Type && _.Name.Equals(newAccount.Name, StringComparison.InvariantCultureIgnoreCase))) { i++; newAccount.Name = string.Format("{0} ({1})", name, i); } _configService.Accounts.Add(newAccount); return newAccount; } MessageService.ShowInfo("This account already exists.\r\nUpdating account data only."); //existingAccount.Name = newAccount.Name; existingAccount.Secret = newAccount.Secret; return existingAccount; }
public ClientStorageMoveSlotPacket(long sourceSlot, long destSlot, StorageType storageType) : this() { SourceSlot = sourceSlot; DestSlot = destSlot; StorageType = storageType; }
internal InventoryPage(InventoryType type, StorageType storage, byte size, Item bag = null) { _type = type; _storage = storage; Size = size; Bag = bag; }
internal DataExpression(DataTable table, string expression, Type type) { ExpressionParser parser = new ExpressionParser(table); parser.LoadExpression(expression); _originalExpression = expression; _expr = null; if (expression != null) { _storageType = DataStorage.GetStorageType(type); if (_storageType == StorageType.BigInteger) { throw ExprException.UnsupportedDataType(type); } _dataType = type; _expr = parser.Parse(); _parsed = true; if (_expr != null && table != null) { Bind(table); } else { _bound = false; } } }
public StorageTypeInfo (StorageType storage_type, string name, string description) { Type = storage_type; Name = name; Description = description; }
public bool AddItem(Player player, StorageType type, KeyValuePair<int, StorageItem> KeyVP) { string SQL = "INSERT INTO `inventory` " + "(`accountname`, `playerid`, `itemid`, `amount`, `color`, `slot`, `storagetype`) " + "VALUES(?accountname, ?pid, ?itemid, ?count, ?color, ?slot, ?type);"; MySqlCommand cmd = new MySqlCommand(SQL, InventoryDAOConnection); cmd.Parameters.AddWithValue("?accountname", player.AccountName); cmd.Parameters.AddWithValue("?pid", player.pid); cmd.Parameters.AddWithValue("?itemid", KeyVP.Value.ItemId); cmd.Parameters.AddWithValue("?count", KeyVP.Value.Count); cmd.Parameters.AddWithValue("?color", KeyVP.Value.Color); cmd.Parameters.AddWithValue("?slot", KeyVP.Key); cmd.Parameters.AddWithValue("?type", type.ToString()); try { cmd.ExecuteNonQuery(); return true; } catch (Exception e) { Log.ErrorException("DAO: ADD ITEM ERROR!", e); } return false; }
private SqlBuffer(SqlBuffer value) { this._isNull = value._isNull; this._type = value._type; this._value = value._value; this._object = value._object; }
internal static bool IsFloat(StorageType type) { if ((type != StorageType.Single) && (type != StorageType.Double)) { return (type == StorageType.Decimal); } return true; }
internal static bool IsIntegerSql(StorageType type) { if (((((type != StorageType.Int16) && (type != StorageType.Int32)) && ((type != StorageType.Int64) && (type != StorageType.UInt16))) && (((type != StorageType.UInt32) && (type != StorageType.UInt64)) && ((type != StorageType.SByte) && (type != StorageType.Byte)))) && (((type != StorageType.SqlInt64) && (type != StorageType.SqlInt32)) && (type != StorageType.SqlInt16))) { return (type == StorageType.SqlByte); } return true; }
internal static bool IsNumericSql(StorageType type) { if (!IsFloatSql(type)) { return IsIntegerSql(type); } return true; }
/// <summary> /// Creates a storage of specified type using metadata information of enumeration value. /// </summary> /// <param name="st">Type of storage to create.</param> /// <param name="storageStr">Connection string or file path for data storage.</param> /// <returns>Newly created storage.</returns> public static AbstractResultStorage CreateStorage(StorageType st, string storageStr) { Type[] patametersType = { typeof(String) }; object[] invokeParameters = { storageStr }; StorageTypeInfo[] info = (StorageTypeInfo[])st.GetType().GetField(st.ToString()).GetCustomAttributes(typeof(StorageTypeInfo), false); Type t = Type.GetType(info[0].Implementation, true); return (AbstractResultStorage)t.GetConstructor(patametersType).Invoke(invokeParameters); }
internal static bool IsFloatSql(StorageType type) { if ((((type != StorageType.Single) && (type != StorageType.Double)) && ((type != StorageType.Decimal) && (type != StorageType.SqlDouble))) && ((type != StorageType.SqlDecimal) && (type != StorageType.SqlMoney))) { return (type == StorageType.SqlSingle); } return true; }
public StorageEntry(List<PetBrokerEntry> list, int funds) { m_Funds = funds; m_StorageType = StorageType.Pet; m_Expires = DateTime.UtcNow + TimeSpan.FromDays(7); foreach (PetBrokerEntry entry in list) m_Creatures.Add(entry.Pet); }
public StorageDescriptor(StorageType type, string friendlyName, string scheme, Func<AccountConfiguration, IStorageProvider> providerFactory, Func<IStorageConfigurator> configuratorFactory, Image smallImage) { Type = type; FriendlyName = friendlyName; Scheme = scheme; ProviderFactory = providerFactory; ConfiguratorFactory = configuratorFactory; SmallImage = smallImage; }
public static string BuildUriString(StorageType type, string accountName, string path) { if (accountName == null) throw new ArgumentNullException("accountName"); if (path == null) throw new ArgumentNullException("path"); var scheme = StorageRegistry.Descriptors.First(_ => _.Type == type).Scheme; return string.Format("{0}:///{1}/{2}", scheme, accountName, path); }
// Checks if a data set exists at the given path. // Storage type is used to correctly interpret the given path. public static bool ExistsImpl(String path, StorageType storageType) { if (storageType==StorageType.STORAGE_APPRESOURCE && QCARRuntimeUtilities.IsPlayMode()) { path = "Assets/StreamingAssets/" + path; } return (QCARWrapper.Instance.DataSetExists(path, (int)storageType) == 1); }
public IConfigLoaderProduct InitializeConfigurationLoader(StorageType type, ConfigManager manager) { switch (type) { case StorageType.Db: { return new DbConfigLoaderProduct(manager); } case StorageType.Xml: { return new XmlConfigLoaderProduct(manager); } default: throw new ConfigurationComponentException(this, -1, "Unable to determine where the configuration data should be loaded from?"); } }
protected override void TryPublish( Type messageType, TopicId topicId, object message, StorageType storageType, bool waitForPublishConfirmation, TimeSpan publishConfirmationTimeout, Dictionary<string, string> headers, TimeSpan expiration) { InSingleProcessMemoryAuthorizer.Verify(AuthorizedMessageOperation.Publish, messageType, message, headers); base.TryPublish(messageType, topicId, message, storageType, waitForPublishConfirmation, publishConfirmationTimeout, headers, expiration); }
internal static bool IsInteger(StorageType type) { return(type == StorageType.Int16 || type == StorageType.Int32 || type == StorageType.Int64 || type == StorageType.UInt16 || type == StorageType.UInt32 || type == StorageType.UInt64 || type == StorageType.SByte || type == StorageType.Byte); }
public async Task<AccountConfiguration> CreateAccount(StorageType type) { var descriptor = StorageRegistry.Descriptors.FirstOrDefault(_ => _.Type == type); if (descriptor == null) throw new NotImplementedException(string.Format("A provider for type '{0}' is not implemented.", type)); var configurator = descriptor.ConfiguratorFactory(); var account = await configurator.CreateAccount(); return account; }
private void ConvertXmlStringToByteArray() { string s = (string) this._object; byte[] bytes = new byte[2 + Encoding.Unicode.GetByteCount(s)]; bytes[0] = 0xff; bytes[1] = 0xfe; Encoding.Unicode.GetBytes(s, 0, s.Length, bytes, 2); this._object = bytes; this._value._int64 = bytes.Length; this._type = StorageType.ByteArray; }
internal Bag(StorageType bagType, Item bag, byte size) : base(InventoryType.Bag, bagType, size, bag) { Debug.Requires(bag != null); Debug.Requires(size % 5 == 0); Debug.Requires(bagType == StorageType.Backpack || bagType == StorageType.BeltPouch || bagType == StorageType.Bag1 || bagType == StorageType.Bag2 || bagType == StorageType.EquipmentPack); }
public StorageEntry(List<CommodityBrokerEntry> list, int funds) { m_Funds = funds; m_StorageType = StorageType.Commodity; foreach (CommodityBrokerEntry entry in list) { if(entry.Stock > 0) m_CommodityTypes[entry.CommodityType] = entry.Stock; } m_Expires = DateTime.UtcNow + TimeSpan.FromDays(7); }
private void ApplyStorageTypeSetting( ) { if ( _settings.PasswordsAreExternal ) { StorageType = StorageType.External; _storage.PasswordRepository.PasswordData = ExternalPasswordData( ); } else { StorageType = StorageType.Internal; _storage.PasswordRepository.PasswordData = InternalPasswordData( ); } }
public StorageWrapperTypeAttribute(StorageType type) { Type = type; }
public StorageFolderFactory(StorageType storageType, string filePath, string commonFolder) { _storageType = storageType; _filePath = filePath; _commonFolder = commonFolder; }
/// <summary> Constructor. </summary> /// <remarks> Sander.struijk, 25.04.2014. </remarks> /// <param name="type"> The type. </param> public IsoStorage(StorageType type) { StorageType = type; }
public ReadStorageItemsJob(BaseDatabase database, StorageType storageType, string storageOwnerId, Action <List <CharacterItem> > onFinished = null) : base(database, onFinished) { this.storageType = storageType; this.storageOwnerId = storageOwnerId; }
internal static extern ErrorCode PackageManagerRequestMove(SafePackageManagerRequestHandle requestHandle, string name, StorageType moveToStorageType);
private static Parameter GetStringValueFromElementBase(Element element, string propertyName, bool allowUnset, out string propertyValue) { propertyValue = string.Empty; if (element == null) { return(null); } if (String.IsNullOrEmpty(propertyName)) { return(null); } ElementId elementId = element.Id; Parameter parameter = GetParameterFromName(elementId, null, propertyName); if (parameter != null) { StorageType storageType = parameter.StorageType; if (storageType != StorageType.String && storageType != StorageType.ElementId) { return(null); } if (parameter.HasValue) { string propValue; propValue = parameter.AsString(); if (!string.IsNullOrEmpty(propValue)) { string propValuetrim = propValue.Trim(); // This is kind of hack to quickly check whether we need to parse the parameter or not if (((propValuetrim.Length > 1 && propValuetrim[0] == '{') || (propValuetrim.Length > 2 && propValuetrim[1] == '{')) && (propValuetrim[propValuetrim.Length - 1] == '}')) { ParamExprResolver pResv = new ParamExprResolver(element, propertyName, propValuetrim); propertyValue = pResv.GetStringValue(); if (string.IsNullOrEmpty(propertyValue)) { propertyValue = propValue; // return the original propValue (un-trimmed) } } else { propertyValue = propValue; // return the original propValue (un-trimmed) } return(parameter); } else if (parameter.AsElementId() != null) { propertyValue = PropertyUtil.ElementIdParameterAsString(parameter); return(parameter); } } if (allowUnset) { propertyValue = null; return(parameter); } } return(null); }
internal static Type GetTypeStorage(StorageType storageType) { Debug.Assert(storageType != StorageType.Empty); return(s_storageClassType[(int)storageType] !); }
public static DataStorage CreateStorage(DataColumn column, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type dataType, StorageType typeCode) { Debug.Assert(typeCode == GetStorageType(dataType), "Incorrect storage type specified"); if ((StorageType.Empty == typeCode) && (null != dataType)) { if (typeof(INullable).IsAssignableFrom(dataType)) { // Udt, OracleTypes return(new SqlUdtStorage(column, dataType)); } else { return(new ObjectStorage(column, dataType)); // non-nullable non-primitives } } switch (typeCode) { case StorageType.Empty: throw ExceptionBuilder.InvalidStorageType(TypeCode.Empty); case StorageType.DBNull: throw ExceptionBuilder.InvalidStorageType((TypeCode)2); // TypeCode.DBNull); case StorageType.Object: return(new ObjectStorage(column, dataType !)); case StorageType.Boolean: return(new BooleanStorage(column)); case StorageType.Char: return(new CharStorage(column)); case StorageType.SByte: return(new SByteStorage(column)); case StorageType.Byte: return(new ByteStorage(column)); case StorageType.Int16: return(new Int16Storage(column)); case StorageType.UInt16: return(new UInt16Storage(column)); case StorageType.Int32: return(new Int32Storage(column)); case StorageType.UInt32: return(new UInt32Storage(column)); case StorageType.Int64: return(new Int64Storage(column)); case StorageType.UInt64: return(new UInt64Storage(column)); case StorageType.Single: return(new SingleStorage(column)); case StorageType.Double: return(new DoubleStorage(column)); case StorageType.Decimal: return(new DecimalStorage(column)); case StorageType.DateTime: return(new DateTimeStorage(column)); case StorageType.TimeSpan: return(new TimeSpanStorage(column)); case StorageType.String: return(new StringStorage(column)); case StorageType.Guid: return(new ObjectStorage(column, dataType !)); case StorageType.ByteArray: return(new ObjectStorage(column, dataType !)); case StorageType.CharArray: return(new ObjectStorage(column, dataType !)); case StorageType.Type: return(new ObjectStorage(column, dataType !)); case StorageType.DateTimeOffset: return(new DateTimeOffsetStorage(column)); case StorageType.BigInteger: return(new BigIntegerStorage(column)); case StorageType.Uri: return(new ObjectStorage(column, dataType !)); case StorageType.SqlBinary: return(new SqlBinaryStorage(column)); case StorageType.SqlBoolean: return(new SqlBooleanStorage(column)); case StorageType.SqlByte: return(new SqlByteStorage(column)); case StorageType.SqlBytes: return(new SqlBytesStorage(column)); case StorageType.SqlChars: return(new SqlCharsStorage(column)); case StorageType.SqlDateTime: return(new SqlDateTimeStorage(column)); case StorageType.SqlDecimal: return(new SqlDecimalStorage(column)); case StorageType.SqlDouble: return(new SqlDoubleStorage(column)); case StorageType.SqlGuid: return(new SqlGuidStorage(column)); case StorageType.SqlInt16: return(new SqlInt16Storage(column)); case StorageType.SqlInt32: return(new SqlInt32Storage(column)); case StorageType.SqlInt64: return(new SqlInt64Storage(column)); case StorageType.SqlMoney: return(new SqlMoneyStorage(column)); case StorageType.SqlSingle: return(new SqlSingleStorage(column)); case StorageType.SqlString: return(new SqlStringStorage(column)); default: Debug.Fail("shouldn't be here"); goto case StorageType.Object; } }
protected DataStorage(DataColumn column, Type type, object?defaultValue, object nullValue, bool isICloneable, StorageType storageType) { Debug.Assert(storageType == GetStorageType(type), "Incorrect storage type specified"); _column = column; _table = column.Table !; _dataType = type; _storageTypeCode = storageType; _defaultValue = defaultValue; _nullValue = nullValue; _isCloneable = isICloneable; _isCustomDefinedType = IsTypeCustomType(_storageTypeCode); _isStringType = ((StorageType.String == _storageTypeCode) || (StorageType.SqlString == _storageTypeCode)); _isValueType = DetermineIfValueType(_storageTypeCode, type); }
protected DataStorage(DataColumn column, Type type, object?defaultValue, object nullValue, StorageType storageType) : this(column, type, defaultValue, nullValue, false, storageType) { }
internal static bool IsNumericSql(StorageType type) { return(IsFloatSql(type) || IsIntegerSql(type)); }
// This function should only be necessary while using ExperimentalAddParameter. private static Parameter GetAddedParameter(Element element, string parameterName, StorageType type) { IList <Parameter> parameterList = element.GetParameters(parameterName); if (parameterList == null) { return(null); } foreach (Parameter parameter in parameterList) { if (parameter.StorageType != type) { continue; } if (parameter.IsReadOnly) { continue; } Definition paramDefinition = parameter.Definition; if (paramDefinition == null) { continue; } if (paramDefinition.ParameterGroup == BuiltInParameterGroup.PG_IFC) { return(parameter); } } // Shouldn't get here. return(null); }
public StorageHelper(StorageType StorageType, string subFolder = null, StorageSerializer serializerType = StorageSerializer.JSON) { _storageType = StorageType; _subFolder = subFolder; _serializerType = serializerType; }
internal static bool IsTypeCustomType(StorageType typeCode) { return((StorageType.Object == typeCode) || (StorageType.Empty == typeCode) || (StorageType.CharArray == typeCode)); }
public static bool InitDefaultStorage(StorageType eStoreType, PackType ePackType) { bool ret = otapiPINVOKE.InitDefaultStorage((int)eStoreType, (int)ePackType); return(ret); }
internal static bool IsSqlType(StorageType storageType) { return(StorageType.SqlBinary <= storageType); }
internal static extern ErrorCode PackageManagerRequestMoveWithCB(SafePackageManagerRequestHandle requestHandle, string name, StorageType moveToStorageType, PackageManagerRequestEventCallback callback, IntPtr userData, out int id);
internal static bool ImplementsINullableValue(StorageType typeCode, Type dataType) { Debug.Assert(typeCode == GetStorageType(dataType), "typeCode mismatches dataType"); return((StorageType.Empty == typeCode) && dataType.IsGenericType && (dataType.GetGenericTypeDefinition() == typeof(System.Nullable <>))); }
public UpdateStorageItemsJob(BaseDatabase database, StorageType storageType, string storageOwnerId, IList <CharacterItem> characterItems, Action onFinished = null) : base(database, onFinished) { this.storageType = storageType; this.storageOwnerId = storageOwnerId; this.characterItems = characterItems; }
/// <summary> /// /// </summary> /// <param name="name"></param> /// <param name="value"></param> /// <param name="storageType"></param> public Parameter(ParameterType parameterType, dynamic value, StorageType storageType) { m_parameterType = parameterType; m_value = value; m_storageType = storageType; }
/// <summary> /// Generic class to simplify the storage and retrieval of data to/from Windows.Storage.ApplicationData /// </summary> /// <param name="StorageType"></param> public ObjectStorageHelper(StorageType StorageType) { serializer = new XmlSerializer(typeof(T)); storageType = StorageType; }
public UseStorageAttribute(StorageType type) { this.Type = type; }
/// <summary> /// 构造方法 /// </summary> /// <param name="storageType">存储器类型</param> /// <param name="connectionString">连接字符串</param> public MySqlEntityStorage(StorageType storageType = StorageType.InsertIgnoreDuplicate, string connectionString = null) : base(storageType, connectionString) { }
/// <summary> /// Sets the storage type in the KeyValueConfiguration. /// </summary> /// <param name="storageType">the storage type</param> /// <returns></returns> public KeyValueConfigurationBuilder WithStorageType(StorageType storageType) { scBuilder.WithStorageType(storageType); return(this); }
public static ElementFilter createParameterFilter(Document doc, ParameterData parameter, string operation, string ruleString) { ElementId parameterId = parameter.Id; ParameterValueProvider fvp = new ParameterValueProvider(parameterId); StorageType storageType = parameter.StorageType; FilterRule fRule = null; FilterInverseRule fInvRule = null; ElementParameterFilter filter = null; switch (storageType) { case StorageType.String: case StorageType.Integer: FilterStringRuleEvaluator fsre = null; switch (operation) { case "равно": fsre = new FilterStringEquals(); fRule = new FilterStringRule(fvp, fsre, ruleString, true); filter = new ElementParameterFilter(fRule); break; case "не равно": fsre = new FilterStringEquals(); fRule = new FilterStringRule(fvp, fsre, ruleString, true); fInvRule = new FilterInverseRule(fRule); filter = new ElementParameterFilter(fInvRule); break; case "содержит": fsre = new FilterStringContains(); fRule = new FilterStringRule(fvp, fsre, ruleString, true); filter = new ElementParameterFilter(fRule); break; case "не содержит": fsre = new FilterStringContains(); fRule = new FilterStringRule(fvp, fsre, ruleString, true); fInvRule = new FilterInverseRule(fRule); filter = new ElementParameterFilter(fInvRule); break; case "начинается с": fsre = new FilterStringBeginsWith(); fRule = new FilterStringRule(fvp, fsre, ruleString, true); filter = new ElementParameterFilter(fRule); break; case "не начинается с": fsre = new FilterStringBeginsWith(); fRule = new FilterStringRule(fvp, fsre, ruleString, true); fInvRule = new FilterInverseRule(fRule); filter = new ElementParameterFilter(fInvRule); break; case "заканчивается на": fsre = new FilterStringEndsWith(); fRule = new FilterStringRule(fvp, fsre, ruleString, true); filter = new ElementParameterFilter(fRule); break; case "не заканчивается на": fsre = new FilterStringEndsWith(); fRule = new FilterStringRule(fvp, fsre, ruleString, true); fInvRule = new FilterInverseRule(fRule); filter = new ElementParameterFilter(fInvRule); break; } break; case StorageType.Double: FilterNumericRuleEvaluator fnre = null; double ruleValue = Convert.ToDouble(ruleString); switch (operation) { case "равно": fnre = new FilterNumericEquals(); fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0); filter = new ElementParameterFilter(fRule); break; case "не равно": fnre = new FilterNumericEquals(); fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0); fInvRule = new FilterInverseRule(fRule); filter = new ElementParameterFilter(fInvRule); break; case "больше": fnre = new FilterNumericGreater(); fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0); filter = new ElementParameterFilter(fRule); break; case "больше или равно": fnre = new FilterNumericGreaterOrEqual(); fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0); filter = new ElementParameterFilter(fRule); break; case "меньше": fnre = new FilterNumericLess(); fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0); filter = new ElementParameterFilter(fRule); break; case "меньше или равно": fnre = new FilterNumericLessOrEqual(); fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0); filter = new ElementParameterFilter(fRule); break; } break; case StorageType.ElementId: var levels = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Levels).ToElements(); var level = levels.Where(i => i.Name == ruleString).FirstOrDefault(); ElementId ruleId = level.Id; fnre = null; switch (operation) { case "равно": fnre = new FilterNumericEquals(); fRule = new FilterElementIdRule(fvp, fnre, ruleId); filter = new ElementParameterFilter(fRule); break; case "не равно": fnre = new FilterNumericEquals(); fRule = new FilterElementIdRule(fvp, fnre, ruleId); fInvRule = new FilterInverseRule(fRule); filter = new ElementParameterFilter(fInvRule); break; case "выше": fnre = new FilterNumericGreater(); fRule = new FilterElementIdRule(fvp, fnre, ruleId); filter = new ElementParameterFilter(fRule); break; case "ровно или выше": fnre = new FilterNumericGreaterOrEqual(); fRule = new FilterElementIdRule(fvp, fnre, ruleId); filter = new ElementParameterFilter(fRule); break; case "ниже": fnre = new FilterNumericLess(); fRule = new FilterElementIdRule(fvp, fnre, ruleId); filter = new ElementParameterFilter(fRule); break; case "ровно или ниже": fnre = new FilterNumericLessOrEqual(); fRule = new FilterElementIdRule(fvp, fnre, ruleId); filter = new ElementParameterFilter(fRule); break; } break; } return(filter); }
public static string ToIoCString(this StorageType storage) { return(storage.ToString().ToUpperInvariant()); }
public DatabaseCreateOperation(string databaseName, DatabaseType databaseType, StorageType storageType, ConnectionMetaData metaData, ServerConnectionOptions options, IOrientDBRecordSerializer <byte[]> serializer, IOrientDBLogger logger) { if (string.IsNullOrWhiteSpace(databaseName)) { throw new ArgumentException($"{nameof(databaseName)} cannot be zero length or null."); } _metaData = metaData ?? throw new ArgumentNullException($"{nameof(metaData)} cannot be null."); _options = options ?? throw new ArgumentNullException($"{nameof(options)} cannot be null."); _serializer = serializer ?? throw new ArgumentNullException($"{nameof(serializer)} cannot be null."); _logger = logger ?? throw new ArgumentNullException($"{nameof(logger)} cannot be null"); _databaseName = databaseName; _databaseType = databaseType; _storageType = storageType; }
internal void Clear() { _isNull = false; _type = StorageType.Empty; _object = null; }
/// <summary> /// 构造方法 /// </summary> /// <param name="storageType">存储器类型</param> /// <param name="connectionString">连接字符串</param> protected RelationalDatabaseEntityStorageBase(StorageType storageType, string connectionString = null) { ConnectionString = connectionString; StorageType = storageType; }
internal static bool IsFloat(StorageType type) { return(type == StorageType.Single || type == StorageType.Double || type == StorageType.Decimal); }