/// <summary>
/// Loads the sprites of the given sprite palette from the given XML-node.
/// </summary>
/// <typeparam name="TVariant">The type of the enumeration that determines the variants of a sprite.</typeparam>
/// <param name="spritePaletteElem">The XML-node to load from.</param>
/// <param name="palette">The target sprite palette.</param>
/// <param name="defaultVariant">The default variant that should be used when no variant was found for a sprite definition.</param>
private static void LoadSprites <TVariant>(XElement spritePaletteElem, SpritePalette <TVariant> palette, TVariant defaultVariant) where TVariant : struct
{
foreach (XElement spriteElem in spritePaletteElem.Elements(SPRITE_ELEM))
{
XAttribute spriteNameAttr = spriteElem.Attribute(SPRITE_NAME_ATTR);
XAttribute spriteVariantAttr = spriteElem.Attribute(SPRITE_VARIANT_ATTR);
XAttribute sourceRegionAttr = spriteElem.Attribute(SPRITE_SOURCEREGION_ATTR);
XAttribute offsetAttr = spriteElem.Attribute(SPRITE_OFFSET_ATTR);
if (spriteNameAttr == null)
{
throw new InvalidOperationException("Sprite name not defined for a sprite in sprite palette!");
}
if (sourceRegionAttr == null)
{
throw new InvalidOperationException("Source region not defined in sprite palette!");
}
TVariant variant = defaultVariant;
if (spriteVariantAttr != null)
{
if (!EnumMap <TVariant, string> .TryDemap(spriteVariantAttr.Value, out variant))
{
throw new InvalidOperationException(string.Format("Unexpected sprite variant '{0}'!", spriteVariantAttr.Value));
}
}
palette.AddSprite(spriteNameAttr.Value,
variant,
XmlHelper.LoadIntRectangle(sourceRegionAttr.Value),
offsetAttr != null ? XmlHelper.LoadIntVector(offsetAttr.Value) : new RCIntVector(0, 0));
}
}
/*--------------------------------------------------------------------------------------------*/
private static string ConvertToken(string pToken)
{
Match m = Regex.Match(pToken, @"('s)?" + DelimSet);
string key = (m.Length == 0 ? pToken : pToken.Replace(m.Value, ""));
string result = key;
if (VertMap.ContainsKey(key))
{
result = "[[" + key + "|Object|" + VertMap[key] + "]]";
//Log.Debug("VERT "+pToken+" // "+key+" // "+(result+m.Value));
}
else if (ObjMap.ContainsKey(key))
{
result = "[[" + key + "|Object|" + ObjMap[key] + "]]";
//Log.Debug("OBJT "+pToken+" // "+key+" // "+(result+m.Value));
}
else if (EdgeMap.ContainsKey(key))
{
result = "[[" + key + "|Edge|" + EdgeMap[key] + "]]";
//Log.Debug("EDGE "+pToken+" // "+key+" // "+(result+m.Value));
}
else if (EnumMap.ContainsKey(key))
{
result = "[[" + key + "|Enum|" + EnumMap[key] + "]]";
//Log.Debug("ENUM "+pToken+" // "+key+" // "+(result+m.Value));
}
else if (key.IndexOf('!') == 0)
{
result = key.Substring(1);
//Log.Debug("EXCL "+pToken+" // "+key+" // "+(result+m.Value));
}
return(result + m.Value);
}
public void ExplicitlyTypedArrayType()
{
var parameter = new BigqueryParameter(BigqueryParameterType.Array, new[] { new DateTimeOffset(new DateTime(2016, 10, 31), new TimeSpan(8, 30, 0)) });
parameter.ArrayType = BigqueryParameterType.DateTime;
string actualJson = JsonConvert.SerializeObject(parameter.ToQueryParameter(BigqueryParameterMode.Positional));
var expectedResult = new QueryParameter
{
ParameterType = new QueryParameterType
{
Type = EnumMap.ToApiValue(BigqueryParameterType.Array),
ArrayType = new QueryParameterType {
Type = EnumMap.ToApiValue(BigqueryParameterType.DateTime)
}
},
ParameterValue = new QueryParameterValue
{
ArrayValues = new[] { new QueryParameterValue {
Value = "2016-10-31 00:00:00"
} }
}
};
string expectedJson = JsonConvert.SerializeObject(expectedResult);
Assert.Equal(actualJson, expectedJson);
}
public void InvalidConversion()
{
Assert.Throws <ArgumentException>(() => EnumMap <WriteDisposition> .ToValue("WRITEIFEMPTY"));
Assert.Throws <ArgumentException>(() => EnumMap <WriteDisposition> .ToValue("Bogus"));
Assert.Throws <ArgumentException>(() => EnumMap <WriteDisposition> .ToValue("Write_Empty"));
Assert.Throws <ArgumentException>(() => EnumMap <WriteDisposition> .ToApiValue((WriteDisposition)100));
}
public virtual void TestReadURL()
{
HttpURLConnection conn = Org.Mockito.Mockito.Mock <HttpURLConnection>();
Org.Mockito.Mockito.DoReturn(new ByteArrayInputStream(FakeLogData)).When(conn).GetInputStream
();
Org.Mockito.Mockito.DoReturn(HttpURLConnection.HttpOk).When(conn).GetResponseCode
();
Org.Mockito.Mockito.DoReturn(Sharpen.Extensions.ToString(FakeLogData.Length)).When
(conn).GetHeaderField("Content-Length");
URLConnectionFactory factory = Org.Mockito.Mockito.Mock <URLConnectionFactory>();
Org.Mockito.Mockito.DoReturn(conn).When(factory).OpenConnection(Org.Mockito.Mockito
.Any <Uri>(), Matchers.AnyBoolean());
Uri url = new Uri("http://localhost/fakeLog");
EditLogInputStream elis = EditLogFileInputStream.FromUrl(factory, url, HdfsConstants
.InvalidTxid, HdfsConstants.InvalidTxid, false);
// Read the edit log and verify that we got all of the data.
EnumMap <FSEditLogOpCodes, Holder <int> > counts = FSImageTestUtil.CountEditLogOpTypes
(elis);
Assert.AssertThat(counts[FSEditLogOpCodes.OpAdd].held, CoreMatchers.Is(1));
Assert.AssertThat(counts[FSEditLogOpCodes.OpSetGenstampV1].held, CoreMatchers.Is(
1));
Assert.AssertThat(counts[FSEditLogOpCodes.OpClose].held, CoreMatchers.Is(1));
// Check that length header was picked up.
NUnit.Framework.Assert.AreEqual(FakeLogData.Length, elis.Length());
elis.Close();
}
/// <summary>
/// Loads a mixed tile type from the XML element into the given tileset.
/// </summary>
/// <param name="fromElem">The XML element to load from.</param>
/// <param name="tileset">The TileSet to load to.</param>
private static void LoadMixedTile(XElement fromElem, TileSet tileset)
{
XAttribute terrainAAttr = fromElem.Attribute(XmlTileSetConstants.MIXEDTILE_TERRAINA_ATTR);
XAttribute terrainBAttr = fromElem.Attribute(XmlTileSetConstants.MIXEDTILE_TERRAINB_ATTR);
XAttribute combinationAttr = fromElem.Attribute(XmlTileSetConstants.MIXEDTILE_COMBINATION_ATTR);
if (terrainAAttr == null)
{
throw new TileSetException("Terrain type A not defined for mixed tile!");
}
if (terrainBAttr == null)
{
throw new TileSetException("Terrain type B not defined for mixed tile!");
}
if (combinationAttr == null)
{
throw new TileSetException("Terrain combination not defined for mixed tile!");
}
TerrainCombination combination;
if (!EnumMap <TerrainCombination, string> .TryDemap(combinationAttr.Value, out combination))
{
throw new TileSetException(string.Format("Unexpected terrain combination '{0}' defined for mixed tile.", combinationAttr.Value));
}
tileset.CreateMixedTileType(terrainAAttr.Value, terrainBAttr.Value, combination);
IsoTileType tile = tileset.GetIsoTileTypeImpl(terrainAAttr.Value, terrainBAttr.Value, combination);
LoadVariants(fromElem, tile, tileset);
}
/// <summary>
/// Ctor
/// </summary>
public MainForm()
{
InitializeComponent();
//Init Scintilla Component
m_scintillaCtrl = new Scintilla();
m_scintillaCtrl.Parent = panelTextEditor;
m_scintillaCtrl.Dock = DockStyle.Fill;
m_scintillaCtrl.Margins[0].Width = 16;
m_scintillaCtrl.TabWidth = 2;
// Configuring the default style with properties
// we have common to every lexer style saves time.
m_scintillaCtrl.StyleResetDefault();
m_scintillaCtrl.Styles[Style.Default].Font = "Consolas";
m_scintillaCtrl.Styles[Style.Default].Size = 10;
m_scintillaCtrl.Styles[Style.Default].BackColor = Color.FromArgb(219, 227, 227);
m_scintillaCtrl.StyleClearAll();
// Configure the lexer styles
m_scintillaCtrl.Styles[Style.Cpp.Default].ForeColor = Color.Silver;
m_scintillaCtrl.Styles[Style.Cpp.Comment].ForeColor = Color.FromArgb(0, 128, 0); // Green
m_scintillaCtrl.Styles[Style.Cpp.CommentLine].ForeColor = Color.FromArgb(0, 128, 0); // Green
m_scintillaCtrl.Styles[Style.Cpp.CommentLineDoc].ForeColor = Color.FromArgb(128, 128, 128); // Gray
m_scintillaCtrl.Styles[Style.Cpp.Number].ForeColor = Color.Olive;
m_scintillaCtrl.Styles[Style.Cpp.Word].ForeColor = Color.Blue;
m_scintillaCtrl.Styles[Style.Cpp.Word2].ForeColor = Color.Blue;
m_scintillaCtrl.Styles[Style.Cpp.String].ForeColor = Color.FromArgb(163, 21, 21); // Red
m_scintillaCtrl.Styles[Style.Cpp.Character].ForeColor = Color.FromArgb(163, 21, 21); // Red
m_scintillaCtrl.Styles[Style.Cpp.Verbatim].ForeColor = Color.FromArgb(163, 21, 21); // Red
m_scintillaCtrl.Styles[Style.Cpp.StringEol].BackColor = Color.Pink;
m_scintillaCtrl.Styles[Style.Cpp.Operator].ForeColor = Color.Purple;
m_scintillaCtrl.Styles[Style.Cpp.Preprocessor].ForeColor = Color.Maroon;
m_scintillaCtrl.Lexer = Lexer.Cpp;
//Create keywords for HLSL
StringBuilder sb = new StringBuilder();
var map = new EnumMap <ShaderToken>();
map.Load("HLSLKeywords.map");
foreach (var kw in map)
{
var str = kw.Key + " ";
if (str[0] == ':')
{
str = str.Substring(1);
}
sb.Append(str);
}
m_scintillaCtrl.SetKeywords(0, sb.ToString());
//MRU
mruMenu = new MruStripMenuInline(fileToolStripMenuItem, recentFilesToolStripMenuItem, new MruStripMenu.ClickedHandler(OnMruFile), mruRegKey + "\\MRU", 16);
mruMenu.LoadFromRegistry();
}
public void clear()
{
EnumMap <Size, Int32> enumSizeMap = new EnumMap <Size, Int32>(typeof(Size));
enumSizeMap.Put(Size.Small, 1);
enumSizeMap.Clear();
Assertion.AssertEquals("Failed to clear all elements", enumSizeMap.Get(Size.Small), default(Int32)); //$NON-NLS-1$
}
/// <summary>
/// Ctor
/// </summary>
public MainForm()
{
InitializeComponent();
//Init Scintilla Component
m_scintillaCtrl = new Scintilla();
m_scintillaCtrl.Parent = panelTextEditor;
m_scintillaCtrl.Dock = DockStyle.Fill;
m_scintillaCtrl.Margins[0].Width = 16;
m_scintillaCtrl.TabWidth = 2;
// Configuring the default style with properties
// we have common to every lexer style saves time.
m_scintillaCtrl.StyleResetDefault();
m_scintillaCtrl.Styles[Style.Default].Font = "Consolas";
m_scintillaCtrl.Styles[Style.Default].Size = 10;
m_scintillaCtrl.Styles[Style.Default].BackColor = Color.FromArgb(219, 227, 227);
m_scintillaCtrl.StyleClearAll();
// Configure the lexer styles
m_scintillaCtrl.Styles[Style.Cpp.Default].ForeColor = Color.Silver;
m_scintillaCtrl.Styles[Style.Cpp.Comment].ForeColor = Color.FromArgb(0, 128, 0); // Green
m_scintillaCtrl.Styles[Style.Cpp.CommentLine].ForeColor = Color.FromArgb(0, 128, 0); // Green
m_scintillaCtrl.Styles[Style.Cpp.CommentLineDoc].ForeColor = Color.FromArgb(128, 128, 128); // Gray
m_scintillaCtrl.Styles[Style.Cpp.Number].ForeColor = Color.Olive;
m_scintillaCtrl.Styles[Style.Cpp.Word].ForeColor = Color.Blue;
m_scintillaCtrl.Styles[Style.Cpp.Word2].ForeColor = Color.Blue;
m_scintillaCtrl.Styles[Style.Cpp.String].ForeColor = Color.FromArgb(163, 21, 21); // Red
m_scintillaCtrl.Styles[Style.Cpp.Character].ForeColor = Color.FromArgb(163, 21, 21); // Red
m_scintillaCtrl.Styles[Style.Cpp.Verbatim].ForeColor = Color.FromArgb(163, 21, 21); // Red
m_scintillaCtrl.Styles[Style.Cpp.StringEol].BackColor = Color.Pink;
m_scintillaCtrl.Styles[Style.Cpp.Operator].ForeColor = Color.Purple;
m_scintillaCtrl.Styles[Style.Cpp.Preprocessor].ForeColor = Color.Maroon;
m_scintillaCtrl.Lexer = Lexer.Cpp;
//Create keywords for HLSL
StringBuilder sb = new StringBuilder();
var map = new EnumMap<ShaderToken>();
map.Load("HLSLKeywords.map");
foreach (var kw in map)
{
var str = kw.Key + " ";
if (str[0] == ':')
str = str.Substring(1);
sb.Append(str);
}
m_scintillaCtrl.SetKeywords(0, sb.ToString());
//MRU
mruMenu = new MruStripMenuInline(fileToolStripMenuItem, recentFilesToolStripMenuItem, new MruStripMenu.ClickedHandler(OnMruFile), mruRegKey + "\\MRU", 16);
mruMenu.LoadFromRegistry();
}
/// <summary>
/// Load a tile-constraint for a terrain object from the given XML element.
/// </summary>
/// <param name="fromElem">The XML element to load from.</param>
/// <param name="terrainObj">The terrain object.</param>
/// <param name="tileset">The tileset being loaded.</param>
/// <returns>The loaded tile-constraint.</returns>
private static ITerrainObjectConstraint LoadTileConstraint(XElement fromElem, TerrainObjectType terrainObj, TileSet tileset)
{
/// Load the attributes of the constraint.
XAttribute quadCoordsAttr = fromElem.Attribute(XmlTileSetConstants.TERRAINOBJ_TILECONSTRAINT_QUADCOORDS_ATTR);
XAttribute terrainAttr = fromElem.Attribute(XmlTileSetConstants.TERRAINOBJ_TILECONSTRAINT_TERRAIN_ATTR);
XAttribute terrainAAttr = fromElem.Attribute(XmlTileSetConstants.TERRAINOBJ_TILECONSTRAINT_TERRAINA_ATTR);
XAttribute terrainBAttr = fromElem.Attribute(XmlTileSetConstants.TERRAINOBJ_TILECONSTRAINT_TERRAINB_ATTR);
XAttribute combinationsAttr = fromElem.Attribute(XmlTileSetConstants.TERRAINOBJ_TILECONSTRAINT_COMBINATIONS_ATTR);
if (quadCoordsAttr == null)
{
throw new TileSetException("Quadratic coordinates not defined for tile constraint element!");
}
if (terrainAttr != null && (terrainAAttr != null || terrainBAttr != null || combinationsAttr != null))
{
throw new TileSetException("Invalid attributes defined for tile constraint on a simple tile!");
}
if (terrainAttr == null && (terrainAAttr == null || terrainBAttr == null || combinationsAttr == null))
{
throw new TileSetException("Invalid attributes defined for tile constraint on a mixed tile!");
}
RCIntVector quadCoords = XmlHelper.LoadIntVector(quadCoordsAttr.Value);
if (terrainObj.IsExcluded(quadCoords))
{
throw new TileSetException(string.Format("TileConstraint at excluded coordinates {0} cannot be defined!", quadCoords));
}
if (terrainAttr != null)
{
TerrainType terrain = tileset.GetTerrainTypeImpl(terrainAttr.Value);
return(new IsoTileConstraint(quadCoords, terrain, tileset));
}
else
{
TerrainType terrainA = tileset.GetTerrainTypeImpl(terrainAAttr.Value);
TerrainType terrainB = tileset.GetTerrainTypeImpl(terrainBAttr.Value);
List <TerrainCombination> combinations = new List <TerrainCombination>();
string[] combinationStrings = combinationsAttr.Value.Split(';');
if (combinationStrings.Length == 0)
{
throw new TileSetException("Terrain combination not defined for tile constraint on a mixed tile!");
}
foreach (string combStr in combinationStrings)
{
TerrainCombination combination;
if (!EnumMap <TerrainCombination, string> .TryDemap(combStr, out combination) || combination == TerrainCombination.Simple)
{
throw new TileSetException(string.Format("Unexpected terrain combination '{0}' defined for tile constraint!", combStr));
}
combinations.Add(combination);
}
return(new IsoTileConstraint(quadCoords, terrainA, terrainB, combinations, tileset));
}
}
/// <summary>
/// Constructs a built-in HeapType.
/// </summary>
/// <param name="builtInType">The built-in type to be constructed.</param>
public HeapType(BuiltInTypeEnum builtInType)
{
/// Members filled at initialization.
switch (builtInType)
{
case BuiltInTypeEnum.Byte:
this.allocationSize = 1;
break;
case BuiltInTypeEnum.Short:
this.allocationSize = 2;
break;
case BuiltInTypeEnum.Integer:
case BuiltInTypeEnum.Number:
this.allocationSize = 4;
break;
case BuiltInTypeEnum.Long:
this.allocationSize = 8;
break;
case BuiltInTypeEnum.IntVector:
case BuiltInTypeEnum.NumVector:
this.allocationSize = 9;
break;
case BuiltInTypeEnum.IntRectangle:
case BuiltInTypeEnum.NumRectangle:
this.allocationSize = 17;
break;
default:
throw new ArgumentException("Unexpected value of 'builtInType'!", "builtInType");
}
string name;
if (!EnumMap <BuiltInTypeEnum, string> .TryMap(builtInType, out name) || name == null)
{
throw new ArgumentException("No name defined for the built-in type!", "builtInType");
}
if (!IDENTIFIER_SYNTAX.IsMatch(name) || name.EndsWith("*"))
{
throw new HeapException(string.Format("Invalid built-in type name '{0}'!", name));
}
this.name = name;
this.builtInType = builtInType;
this.pointedTypeID = -1;
this.fieldTypeIDs = null;
this.fieldOffsets = null;
this.tmpFieldTypeNames = null;
this.fieldIndices = null;
/// Members that will be filled during validation.
this.id = -1;
}
private static QueryParameter ScalarParameter(BigqueryParameterType type, string value) =>
new QueryParameter
{
ParameterType = new QueryParameterType {
Type = EnumMap.ToApiValue(type)
},
ParameterValue = new QueryParameterValue {
Value = value
}
};
public void TypeInference(string name, object value, BigQueryDbType expectedType)
{
var parameter = new BigQueryParameter();
parameter.Value = value;
var queryParameter = parameter.ToQueryParameter();
var actualType = EnumMap <BigQueryDbType> .ToValue(queryParameter.ParameterType.Type);
Assert.Equal(expectedType, actualType);
}
public void InvalidConversion()
{
Assert.Throws <ArgumentException>(() => EnumMap <WriteDisposition> .ToValue("WRITEIFEMPTY"));
Assert.Throws <ArgumentException>(() => EnumMap <WriteDisposition> .ToValue("Bogus"));
Assert.Throws <ArgumentException>(() => EnumMap <WriteDisposition> .ToValue("Write_Empty"));
Assert.Throws <ArgumentException>(() => EnumMap <WriteDisposition> .ToApiValue((WriteDisposition)100));
Assert.Throws <TypeInitializationException>(() => EnumMap <SchemaUpdateOption> .ToApiValue(SchemaUpdateOption.AllowFieldAddition));
Assert.Throws <ArgumentException>(() => FlagsEnumMap <SchemaUpdateOption> .ToApiValues((SchemaUpdateOption)100));
Assert.Throws <TypeInitializationException>(() => FlagsEnumMap <WriteDisposition> .ToApiValues(WriteDisposition.WriteAppend));
}
/// <summary>
/// Creates an instance of the given type defined in the given XML-load.
/// </summary>
/// <typeparam name="T">The type of the instance to be created.</typeparam>
/// <param name="sourceElem">The XML-node that contains informations about the instantiation.</param>
/// <returns>The created instance of type T.</returns>
public static T CreateInstance <T>(XElement sourceElem)
{
/// Get the name of the assembly that contains the class to be instantiated.
XAttribute assemblyAttr = sourceElem.Attribute(INSTANTIATION_ASSEMBLY_ATTR);
if (assemblyAttr == null)
{
throw new ConfigurationException(string.Format("'{0}' attribute not found!", INSTANTIATION_ASSEMBLY_ATTR));
}
/// Get the name of the class to be instantiated.
XAttribute classElem = sourceElem.Attribute(INSTANTIATION_CLASS_ATTR);
if (classElem == null)
{
throw new ConfigurationException(string.Format("'{0}' attribute not found!", INSTANTIATION_CLASS_ATTR));
}
/// Collect the parameters for the constructor.
List <object> ctorParams = new List <object>();
foreach (XElement paramElem in sourceElem.Elements(INSTANTIATION_CTORPARAM_ELEM))
{
XAttribute paramTypeAttr = paramElem.Attribute(INSTANTIATION_CTORPARAM_TYPE_ATTR);
if (paramTypeAttr == null)
{
throw new ConfigurationException("No type defined for trace constructor parameter!");
}
/// Try to parse the type attribute.
CtorParamType paramType;
if (!EnumMap <CtorParamType, string> .TryDemap(paramTypeAttr.Value, out paramType))
{
throw new ConfigurationException(string.Format("Unexpected constructor parameter type '{0}' defined.", paramTypeAttr.Value));
}
object parameter = ParseParameterValue(paramElem.Value, paramType);
ctorParams.Add(parameter);
}
/// Load the assembly that contains the class and create an instance of that class.
Assembly asm = Assembly.Load(assemblyAttr.Value);
if (asm == null)
{
throw new ConfigurationException(string.Format("Unable to load assembly '{0}'!", assemblyAttr.Value));
}
Type objType = asm.GetType(classElem.Value);
if (objType == null)
{
throw new ConfigurationException(string.Format("Unable to load type '{0}' from assembly '{1}'!", classElem.Value, assemblyAttr.Value));
}
return((T)Activator.CreateInstance(objType, ctorParams.ToArray()));
}
/// <summary>Calculates mask entries required for the ACL.</summary>
/// <remarks>
/// Calculates mask entries required for the ACL. Mask calculation is performed
/// separately for each scope: access and default. This method is responsible
/// for handling the following cases of mask calculation:
/// 1. Throws an exception if the caller attempts to remove the mask entry of an
/// existing ACL that requires it. If the ACL has any named entries, then a
/// mask entry is required.
/// 2. If the caller supplied a mask in the ACL spec, use it.
/// 3. If the caller did not supply a mask, but there are ACL entry changes in
/// this scope, then automatically calculate a new mask. The permissions of
/// the new mask are the union of the permissions on the group entry and all
/// named entries.
/// </remarks>
/// <param name="aclBuilder">ArrayList<AclEntry> containing entries to build</param>
/// <param name="providedMask">
/// EnumMap<AclEntryScope, AclEntry> mapping each scope to
/// the mask entry that was provided for that scope (if provided)
/// </param>
/// <param name="maskDirty">
/// EnumSet<AclEntryScope> which contains a scope if the mask
/// entry is dirty (added or deleted) in that scope
/// </param>
/// <param name="scopeDirty">
/// EnumSet<AclEntryScope> which contains a scope if any entry
/// is dirty (added or deleted) in that scope
/// </param>
/// <exception cref="Org.Apache.Hadoop.Hdfs.Protocol.AclException">if validation fails
/// </exception>
private static void CalculateMasks(IList <AclEntry> aclBuilder, EnumMap <AclEntryScope
, AclEntry> providedMask, EnumSet <AclEntryScope> maskDirty, EnumSet <AclEntryScope
> scopeDirty)
{
EnumSet <AclEntryScope> scopeFound = EnumSet.NoneOf <AclEntryScope>();
EnumMap <AclEntryScope, FsAction> unionPerms = Maps.NewEnumMap <AclEntryScope>();
EnumSet <AclEntryScope> maskNeeded = EnumSet.NoneOf <AclEntryScope>();
// Determine which scopes are present, which scopes need a mask, and the
// union of group class permissions in each scope.
foreach (AclEntry entry in aclBuilder)
{
scopeFound.AddItem(entry.GetScope());
if (entry.GetType() == AclEntryType.Group || entry.GetName() != null)
{
FsAction scopeUnionPerms = Objects.FirstNonNull(unionPerms[entry.GetScope()], FsAction
.None);
unionPerms[entry.GetScope()] = scopeUnionPerms.Or(entry.GetPermission());
}
if (entry.GetName() != null)
{
maskNeeded.AddItem(entry.GetScope());
}
}
// Add mask entry if needed in each scope.
foreach (AclEntryScope scope in scopeFound)
{
if (!providedMask.Contains(scope) && maskNeeded.Contains(scope) && maskDirty.Contains
(scope))
{
// Caller explicitly removed mask entry, but it's required.
throw new AclException("Invalid ACL: mask is required and cannot be deleted.");
}
else
{
if (providedMask.Contains(scope) && (!scopeDirty.Contains(scope) || maskDirty.Contains
(scope)))
{
// Caller explicitly provided new mask, or we are preserving the existing
// mask in an unchanged scope.
aclBuilder.AddItem(providedMask[scope]);
}
else
{
if (maskNeeded.Contains(scope) || providedMask.Contains(scope))
{
// Otherwise, if there are maskable entries present, or the ACL
// previously had a mask, then recalculate a mask automatically.
aclBuilder.AddItem(new AclEntry.Builder().SetScope(scope).SetType(AclEntryType.Mask
).SetPermission(unionPerms[scope]).Build());
}
}
}
}
}
public static IDictionary <IntegralType, int?> generateMap(string instruction)
{
IList <int?> current = map[instruction];
IDictionary <IntegralType, int?> hmap = new EnumMap <IntegralType, int?>(typeof(IntegralType));
hmap[IntegralType.jinteger] = current[0];
hmap[IntegralType.jlong] = current[1];
hmap[IntegralType.jfloat] = current[2];
hmap[IntegralType.jdouble] = current[3];
return(hmap);
}
/// <summary>
/// Loads the condition of a conditional branch from the given XML element.
/// </summary>
/// <param name="fromElem">The XML element to load from.</param>
/// <param name="tileset">The tileset being loaded.</param>
/// <returns>The loaded condition.</returns>
private static IIsoTileCondition LoadCondition(XElement fromElem, TileSet tileset)
{
if (fromElem.Name == XmlTileSetConstants.NEIGHBOURCOND_ELEM)
{
/// Load neighbour condition.
XAttribute whichNeighbourAttr = fromElem.Attribute(XmlTileSetConstants.NEIGHBOURCOND_WHICH_ATTR);
XAttribute whatCombinationAttr = fromElem.Attribute(XmlTileSetConstants.NEIGHBOURCOND_COMBINATION_ATTR);
if (whichNeighbourAttr == null)
{
throw new TileSetException("Neighbour not defined for a neighbour condition!");
}
if (whatCombinationAttr == null)
{
throw new TileSetException("Terrain combination not defined for a neighbour condition!");
}
TerrainCombination combination;
if (!EnumMap <TerrainCombination, string> .TryDemap(whatCombinationAttr.Value, out combination))
{
throw new TileSetException(string.Format("Unexpected terrain combination '{0}' defined for neighbour condition!", whatCombinationAttr.Value));
}
MapDirection neighbour;
if (!EnumMap <MapDirection, string> .TryDemap(whichNeighbourAttr.Value, out neighbour))
{
throw new TileSetException(string.Format("Unexpected neighbour direction '{0}' defined for neighbour condition!", whichNeighbourAttr.Value));
}
return(new NeighbourCondition(combination, neighbour, tileset));
}
else if (fromElem.Name == XmlTileSetConstants.COMPLEXCOND_AND_ELEM ||
fromElem.Name == XmlTileSetConstants.COMPLEXCOND_OR_ELEM ||
fromElem.Name == XmlTileSetConstants.COMPLEXCOND_NOT_ELEM)
{
/// Load complex condition.
LogicalOp logicalOp;
if (!EnumMap <LogicalOp, string> .TryDemap(fromElem.Name.LocalName, out logicalOp))
{
throw new TileSetException(string.Format("Unexpected logical operator '{0}' defined for complex condition!", fromElem.Name.LocalName));
}
List <IIsoTileCondition> subconditions = new List <IIsoTileCondition>();
foreach (XElement subconditionElem in fromElem.Elements())
{
subconditions.Add(LoadCondition(subconditionElem, tileset));
}
return(new ComplexCondition(subconditions, logicalOp, tileset));
}
else
{
throw new TileSetException(string.Format("Unexpected condition element: {0}!", fromElem.Name.LocalName));
}
}
public void OnAfterDeserialize()
{
_colorMap = new EnumMap <Hitbox.Type, Color>();
_colorMap[Hitbox.Type.Inactive] = _inactiveHitboxColor;
_colorMap[Hitbox.Type.Offensive] = _offensiveHitboxColor;
_colorMap[Hitbox.Type.Damageable] = _damageableHitboxColor;
_colorMap[Hitbox.Type.Invincible] = _invincibleHitboxColor;
_colorMap[Hitbox.Type.Intangible] = _intangibleHitboxColor;
_colorMap[Hitbox.Type.Absorb] = _absorbHitboxColor;
_colorMap[Hitbox.Type.Shield] = _shieldHitboxColor;
_colorMap[Hitbox.Type.Reflective] = ReflectHitboxColor;
}
/// <summary>
/// Cache the built-in ECMAScript objects to protect them against
/// modifications by the script.
/// </summary>
/// <remarks>
/// Cache the built-in ECMAScript objects to protect them against
/// modifications by the script. This method is called automatically by
/// <see cref="ScriptRuntime.InitStandardObjects(Context, ScriptableObject, bool)">ScriptRuntime.initStandardObjects</see>
/// if the scope argument is an instance of this class. It only has to be
/// called by the embedding if a top-level scope is not initialized through
/// <code>initStandardObjects()</code>.
/// </remarks>
public virtual void CacheBuiltins()
{
ctors = new EnumMap<TopLevel.Builtins, BaseFunction>(typeof(TopLevel.Builtins));
foreach (TopLevel.Builtins builtin in TopLevel.Builtins.Values())
{
object value = ScriptableObject.GetProperty(this, builtin.ToString());
if (value is BaseFunction)
{
ctors.Put(builtin, (BaseFunction)value);
}
}
}
public void ArrayTypeInference(string name, object value, BigQueryDbType expectedArrayType)
{
var parameter = new BigQueryParameter();
parameter.Value = value;
var queryParameter = parameter.ToQueryParameter(BigQueryParameterMode.Positional);
Assert.Equal(BigQueryDbType.Array.ToParameterApiType(), queryParameter.ParameterType.Type);
var actualArrayType = EnumMap <BigQueryDbType> .ToValue(queryParameter.ParameterType.ArrayType.Type);
Assert.Equal(expectedArrayType, actualArrayType);
}
public UInt64EnumJsonConverter(Serializer serializer, PropertyInfo propInfo)
{
_map = EnumMap.For <T>();
_keyConverter = serializer.GetConverter <Utf8String>(propInfo, true);
if (typeof(T).GetTypeInfo().GetCustomAttribute <FlagsAttribute>() == null && _map.MaxValue <= Int53Attribute.MaxValue)
{
_valueConverter = new UInt53JsonConverter();
}
else
{
_valueConverter = new UInt64JsonConverter();
}
}
public MouseClickDetector(IComponentEventSource <MouseEventData, IWidget> eventSource)
{
DragThreshold = 4;
DoubleClickDelay = 0.5f;
queue = new EventQueue <MouseEventData>();
this.eventSource = eventSource;
lastDownTime = new EnumMap <MouseButton, MouseClickRecord>(buttons);
lastDownTime.Fill(MouseClickRecord.Invalid);
lastComponentSeen = new WeakReference <IWidget>(null);
}
/// <summary>
/// Loads the general data of a scenario element type from the given element.
/// </summary>
/// <param name="genDataElem">The XML element to load from.</param>
/// <param name="elementType">The scenario element type being constructed.</param>
private static void LoadGeneralData(XElement genDataElem, ScenarioElementType elementType)
{
XElement areaElem = genDataElem.Element(XmlMetadataConstants.GENDATA_AREA_ELEM);
XElement obstacleAreaElem = genDataElem.Element(XmlMetadataConstants.GENDATA_OBSTACLEAREA_ELEM);
XElement armorElem = genDataElem.Element(XmlMetadataConstants.GENDATA_ARMOR_ELEM);
XElement maxEnergyElem = genDataElem.Element(XmlMetadataConstants.GENDATA_MAXENERGY_ELEM);
XElement maxHPElem = genDataElem.Element(XmlMetadataConstants.GENDATA_MAXHP_ELEM);
XElement sightRangeElem = genDataElem.Element(XmlMetadataConstants.GENDATA_SIGHTRANGE_ELEM);
XElement sizeElem = genDataElem.Element(XmlMetadataConstants.GENDATA_SIZE_ELEM);
XElement speedElem = genDataElem.Element(XmlMetadataConstants.GENDATA_SPEED_ELEM);
if (areaElem != null)
{
elementType.SetArea(XmlHelper.LoadNumRectangle(areaElem.Value));
}
if (obstacleAreaElem != null)
{
elementType.SetObstacleArea(XmlHelper.LoadIntRectangle(obstacleAreaElem.Value));
}
if (armorElem != null)
{
elementType.SetArmor(XmlHelper.LoadInt(armorElem.Value));
}
if (maxEnergyElem != null)
{
elementType.SetMaxEnergy(XmlHelper.LoadInt(maxEnergyElem.Value));
}
if (maxHPElem != null)
{
elementType.SetMaxHP(XmlHelper.LoadInt(maxHPElem.Value));
}
if (sightRangeElem != null)
{
elementType.SetSightRange(XmlHelper.LoadInt(sightRangeElem.Value));
}
if (speedElem != null)
{
elementType.SetSpeed(XmlHelper.LoadNum(speedElem.Value));
}
if (sizeElem != null)
{
SizeEnum size;
if (!EnumMap <SizeEnum, string> .TryDemap(sizeElem.Value, out size))
{
throw new SimulatorException(string.Format("Unexpected size '{0}' defined in general data!", sizeElem.Value));
}
elementType.SetSize(size);
}
}
public void containsKeyLjava_lang_Object()
{
EnumMap <Size, Int32> enumSizeMap = new EnumMap <Size, Int32>(typeof(Size));
Assertion.Assert("Returned true for uncontained key", !enumSizeMap //$NON-NLS-1$
.ContainsKey(Size.Small));
enumSizeMap.Put(Size.Small, 1);
Assertion.Assert("Returned false for contained key", enumSizeMap //$NON-NLS-1$
.ContainsKey(Size.Small));
/*
* enumSizeMap.Put(Size.Big, null);
* Assertion.Assert("Returned false for contained key", enumSizeMap //$NON-NLS-1$
* .ContainsKey(Size.Big));*/
}
/// <summary>
/// 初始化编辑器文本处理器
/// </summary>
private void InitEditorScintillaCtrl()
{
m_EditorScintillaCtrl = new Scintilla();
m_EditorScintillaCtrl.Parent = EditorPanel;
m_EditorScintillaCtrl.Dock = DockStyle.Fill;
m_EditorScintillaCtrl.Margins[0].Width = 16;
m_EditorScintillaCtrl.TabWidth = 2;
m_EditorScintillaCtrl.StyleResetDefault();
m_EditorScintillaCtrl.Styles[Style.Default].Font = "Consolas";
m_EditorScintillaCtrl.Styles[Style.Default].Size = 10;
m_EditorScintillaCtrl.Styles[Style.Default].BackColor = Color.FromArgb(219, 227, 227);
m_EditorScintillaCtrl.StyleClearAll();
m_EditorScintillaCtrl.Styles[Style.Cpp.Default].ForeColor = Color.Silver;
m_EditorScintillaCtrl.Styles[Style.Cpp.Comment].ForeColor = Color.FromArgb(0, 128, 0); // Green
m_EditorScintillaCtrl.Styles[Style.Cpp.CommentLine].ForeColor = Color.FromArgb(0, 128, 0); // Green
m_EditorScintillaCtrl.Styles[Style.Cpp.CommentLineDoc].ForeColor = Color.FromArgb(128, 128, 128); // Gray
m_EditorScintillaCtrl.Styles[Style.Cpp.Number].ForeColor = Color.Olive;
m_EditorScintillaCtrl.Styles[Style.Cpp.Word].ForeColor = Color.Blue;
m_EditorScintillaCtrl.Styles[Style.Cpp.Word2].ForeColor = Color.Blue;
m_EditorScintillaCtrl.Styles[Style.Cpp.String].ForeColor = Color.FromArgb(163, 21, 21); // Red
m_EditorScintillaCtrl.Styles[Style.Cpp.Character].ForeColor = Color.FromArgb(163, 21, 21); // Red
m_EditorScintillaCtrl.Styles[Style.Cpp.Verbatim].ForeColor = Color.FromArgb(163, 21, 21); // Red
m_EditorScintillaCtrl.Styles[Style.Cpp.StringEol].BackColor = Color.Pink;
m_EditorScintillaCtrl.Styles[Style.Cpp.Operator].ForeColor = Color.Purple;
m_EditorScintillaCtrl.Styles[Style.Cpp.Preprocessor].ForeColor = Color.Maroon;
m_EditorScintillaCtrl.Lexer = Lexer.Cpp;
// 添加 HLSL 关键字
StringBuilder sb = new StringBuilder();
var map = new EnumMap <ENUM_ShaderTokenType>();
map.Load("Content\\Config\\HLSLKeywords.map");
foreach (var kw in map)
{
var str = kw.Key + " ";
if (str[0] == ':')
{
str = str.Substring(1);
}
sb.Append(str);
}
m_EditorScintillaCtrl.SetKeywords(0, sb.ToString());
}
public void ConstructorLjava_util_EnumMap()
{
EnumMap <Color, Double> enumColorMap = null;
enumColorMap = new EnumMap <Color, Double>(typeof(Color));
Double double1 = 1;
enumColorMap.Put(Color.Green, 2);
enumColorMap.Put(Color.Blue, double1);
EnumMap <Color, Double> enumMap = new EnumMap <Color, Double>(enumColorMap);
Assertion.AssertEquals("Constructor fails", 2, enumMap.Get(Color.Green)); //$NON-NLS-1$
Assertion.AssertEquals("Constructor fails", double1, enumMap.Get(Color.Blue)); //$NON-NLS-1$
Assertion.AssertEquals("Constructor fails", enumMap.Get(Color.Red), default(Double)); //$NON-NLS-1$
enumMap.Put(Color.Red, 1);
Assertion.AssertEquals("Wrong value", 1, enumMap.Get(Color.Red)); //$NON-NLS-1$
}
public void test_putLjava_lang_ObjectLjava_lang_Object()
{
EnumMap <Size, Int32> enumSizeMap = new EnumMap <Size, Int32>(typeof(Size));
/*try {
* enumSizeMap.put(Color.Red, 2);
* fail("Expected ClassCastException"); //$NON-NLS-1$
* } catch (ClassCastException e) {
* // Expected
* }*/
Assertion.AssertEquals("Return non-null for non mapped key", enumSizeMap.Put( //$NON-NLS-1$
Size.Small, 1), 0);
EnumMap <Color, Double> enumColorMap = new EnumMap <Color, Double>(typeof(Color));
/*try {
* enumColorMap.put(Size.Big, 2);
* fail("Expected ClassCastException"); //$NON-NLS-1$
* } catch (ClassCastException e) {
* // Expected
* }
* try {
* enumColorMap.put(null, 2);
* fail("Expected NullPointerException"); //$NON-NLS-1$
* } catch (NullPointerException e) {
* // Expected
* }*/
Assertion.AssertEquals("Return non-null for non mapped key", enumColorMap.Put( //$NON-NLS-1$
Color.Green, 2), 0);
Assertion.AssertEquals("Return wrong value", 2, enumColorMap.Put(Color.Green, //$NON-NLS-1$
4));
Assertion.AssertEquals("Return wrong value", 4, enumColorMap.Put( //$NON-NLS-1$
Color.Green, Int32.Parse("3"))); //$NON-NLS-1$
Assertion.AssertEquals("Return wrong value", Int32.Parse("3"), enumColorMap.Put( //$NON-NLS-1$//$NON-NLS-2$
Color.Green, 0));
Single f = Single.Parse("3.4"); //$NON-NLS-1$
Assertion.AssertEquals("Return non-null for non mapped key", enumColorMap.Put( //$NON-NLS-1$
Color.Green, f), 0);
Assertion.AssertEquals("Return non-null for non mapped key", enumColorMap.Put( //$NON-NLS-1$
Color.Blue, 2), 0);
Assertion.AssertEquals("Return wrong value", 2, enumColorMap.Put(Color.Blue, //$NON-NLS-1$
4));
}
/// <summary>Completely replaces the ACL with the entries of the ACL spec.</summary>
/// <remarks>
/// Completely replaces the ACL with the entries of the ACL spec. If
/// necessary, recalculates the mask entries. If necessary, default entries
/// are inferred by copying the permissions of the corresponding access
/// entries. Replacement occurs separately for each of the access ACL and the
/// default ACL. If the ACL spec contains only access entries, then the
/// existing default entries are retained. If the ACL spec contains only
/// default entries, then the existing access entries are retained. If the ACL
/// spec contains both access and default entries, then both are replaced.
/// </remarks>
/// <param name="existingAcl">List<AclEntry> existing ACL</param>
/// <param name="inAclSpec">List<AclEntry> ACL spec containing replacement entries</param>
/// <returns>List<AclEntry> new ACL</returns>
/// <exception cref="Org.Apache.Hadoop.Hdfs.Protocol.AclException">if validation fails
/// </exception>
public static IList <AclEntry> ReplaceAclEntries(IList <AclEntry> existingAcl, IList
<AclEntry> inAclSpec)
{
AclTransformation.ValidatedAclSpec aclSpec = new AclTransformation.ValidatedAclSpec
(inAclSpec);
AList <AclEntry> aclBuilder = Lists.NewArrayListWithCapacity(MaxEntries);
// Replacement is done separately for each scope: access and default.
EnumMap <AclEntryScope, AclEntry> providedMask = Maps.NewEnumMap <AclEntryScope>();
EnumSet <AclEntryScope> maskDirty = EnumSet.NoneOf <AclEntryScope>();
EnumSet <AclEntryScope> scopeDirty = EnumSet.NoneOf <AclEntryScope>();
foreach (AclEntry aclSpecEntry in aclSpec)
{
scopeDirty.AddItem(aclSpecEntry.GetScope());
if (aclSpecEntry.GetType() == AclEntryType.Mask)
{
providedMask[aclSpecEntry.GetScope()] = aclSpecEntry;
maskDirty.AddItem(aclSpecEntry.GetScope());
}
else
{
aclBuilder.AddItem(aclSpecEntry);
}
}
// Copy existing entries if the scope was not replaced.
foreach (AclEntry existingEntry in existingAcl)
{
if (!scopeDirty.Contains(existingEntry.GetScope()))
{
if (existingEntry.GetType() == AclEntryType.Mask)
{
providedMask[existingEntry.GetScope()] = existingEntry;
}
else
{
aclBuilder.AddItem(existingEntry);
}
}
}
CopyDefaultsIfNeeded(aclBuilder);
CalculateMasks(aclBuilder, providedMask, maskDirty, scopeDirty);
return(BuildAndValidateAcl(aclBuilder));
}
public void getLjava_lang_Object()
{
EnumMap <Size, Int32> enumSizeMap = new EnumMap <Size, Int32>(typeof(Size));
Assertion.AssertEquals("Get returned non-null for non mapped key", enumSizeMap //$NON-NLS-1$
.Get(Size.Big), 0);
enumSizeMap.Put(Size.Big, 1);
Assertion.AssertEquals("Get returned incorrect value for given key", 1, //$NON-NLS-1$
enumSizeMap.Get(Size.Big));
Assertion.AssertEquals("Get returned non-null for non mapped key", enumSizeMap //$NON-NLS-1$
.Get(Size.Small), 0);
Assertion.AssertEquals("Get returned non-null for non existent key", enumSizeMap //$NON-NLS-1$
.Get(Color.Red), 0);
Assertion.AssertEquals("Get returned non-null for non existent key", enumSizeMap //$NON-NLS-1$
.Get(1), 0);
Assertion.AssertEquals("Get returned non-null for non existent key", enumSizeMap //$NON-NLS-1$
.Get(null), 0);
EnumMap <Color, Double> enumColorMap = new EnumMap <Color, Double>(typeof(Color));
Assertion.AssertEquals("Get returned non-null for non mapped key", enumColorMap //$NON-NLS-1$
.Get(Color.Green), 0);
enumColorMap.Put(Color.Green, 2);
Assertion.AssertEquals("Get returned incorrect value for given key", 2, //$NON-NLS-1$
enumColorMap.Get(Color.Green));
Assertion.AssertEquals("Get returned non-null for non mapped key", enumColorMap //$NON-NLS-1$
.Get(Color.Blue), 0);
enumColorMap.Put(Color.Green, 4);
Assertion.AssertEquals("Get returned incorrect value for given key", //$NON-NLS-1$
4, enumColorMap.Get(Color.Green));
enumColorMap.Put(Color.Green, Int32.Parse("3")); //$NON-NLS-1$
Assertion.AssertEquals("Get returned incorrect value for given key", Int32.Parse( //$NON-NLS-1$
"3"), enumColorMap.Get(Color.Green)); //$NON-NLS-1$
enumColorMap.Put(Color.Green, 0);
Assertion.AssertEquals("Can not handle null value", enumColorMap.Get(Color.Green), 0); //$NON-NLS-1$
Single f = Single.Parse("3.4"); //$NON-NLS-1$
enumColorMap.Put(Color.Green, f);
Assertion.AssertEquals("Get returned incorrect value for given key", f, //$NON-NLS-1$
enumColorMap.Get(Color.Green), 0.000001);
}
/// <seealso cref="CountEditLogOpTypes(Sharpen.FilePath)"/>
/// <exception cref="System.IO.IOException"/>
public static EnumMap <FSEditLogOpCodes, Holder <int> > CountEditLogOpTypes(EditLogInputStream
elis)
{
EnumMap <FSEditLogOpCodes, Holder <int> > opCounts = new EnumMap <FSEditLogOpCodes, Holder
<int> >(typeof(FSEditLogOpCodes));
FSEditLogOp op;
while ((op = elis.ReadOp()) != null)
{
Holder <int> i = opCounts[op.opCode];
if (i == null)
{
i = new Holder <int>(0);
opCounts[op.opCode] = i;
}
i.held++;
}
return(opCounts);
}
private string GetStorageAllocationAsString()
{
IDictionary <StorageType, int> storageType_countmap = new EnumMap <StorageType, int
>(typeof(StorageType));
foreach (StorageType storageType in storageTypes)
{
int count = storageType_countmap[storageType];
if (count == null)
{
storageType_countmap[storageType] = 1;
}
else
{
storageType_countmap[storageType] = count + 1;
}
}
return(GetStorageAllocationAsString(storageType_countmap));
}
// 由于C#中没有static indexer的概念，所以在这里我们用静态方法
public static string GetStringFromEnum(Enum item)
{
if (maps == null)
{
maps = new Dictionary<Type, EnumMap>();
}
Type enumType = item.GetType();
EnumMap mapper = null;
if (maps.ContainsKey(enumType))
{
mapper = maps[enumType];
}
else
{
mapper = new EnumMap(enumType);
maps.Add(enumType, mapper);
}
return mapper[item];
}
static UNITYShaderTokenProvider()
{
map = new EnumMap<ShaderToken>();
map.Load("UNITYKeywords.map");
}
static MAsmHighlighterTokenProvider()
{
map = new EnumMap<AsmHighlighterToken>();
map.Load("MASMKeywords.map");
}
static HLSLShaderTokenProvider()
{
map = new EnumMap<ShaderToken>();
map.Load("HLSLKeywords.map");
}
static ParadoxShaderTokenProvider()
{
map = new EnumMap<ShaderToken>();
map.Load("ParadoxShaderKeywords.map");
}
static XenkoShaderTokenProvider()
{
map = new EnumMap<ShaderToken>();
map.Load("XenkoShaderKeywords.map");
}
public EnumMapExample(EnumMap<Number, String> numbers) {
this.numbers = numbers;
}