public static void Encode( Packer packer, Type type )
{
var assemblyName =
#if !SILVERLIGHT
type.GetAssembly().GetName();
#else
new AssemblyName( type.GetAssembly().FullName );
#endif // !SILVERLIGHT
// Omit namespace prefix when it equals to declaring assembly simple name.
#if DEBUG && !UNITY
Contract.Assert( type.Namespace != null, "type.Namespace != null" );
#endif // DEBUG && !UNITY
var compressedTypeName =
type.Namespace.StartsWith( assemblyName.Name, StringComparison.Ordinal )
? Elipsis + type.FullName.Substring( assemblyName.Name.Length )
: type.FullName;
var version = new byte[ 16 ];
Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Major ), 0, version, 0, 4 );
Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Minor ), 0, version, 4, 4 );
Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Build ), 0, version, 8, 4 );
Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Revision ), 0, version, 12, 4 );
packer.PackArrayHeader( 5 )
.Pack( compressedTypeName )
.Pack( assemblyName.Name )
.Pack( version )
#if !XAMIOS && !XAMDROID
.Pack( assemblyName.GetCultureName() )
#else
.Pack( assemblyName.GetCultureName() == "neutral" ? null : assemblyName.GetCultureName() )
#endif // !XAMIOS && !XAMDROID
.Pack( assemblyName.GetPublicKeyToken() );
}
public void PackUnpack()
{
var bordas = Enumerable.Range(1, 10)
.Select(x => TestDataProvider.RandomBorda())
.ToList();
//var bordaCopy = borda.Select(x => (Borda)x.Clone()).ToArray();
var packer = new Packer();
foreach (Borda borda in bordas)
{
lock (OutputFileLock)
{
var key = TestDataProvider.RandomText();
if (File.Exists(destFile))
File.Delete(destFile);
packer.Pack(borda, key, sourceFile, destFile);
var unpackedBorda = packer.Unpack(destFile, key);
Assert.True(borda.Threads.Count == unpackedBorda.Threads.Count);
Assert.True(borda.Threads.SequenceEqual(unpackedBorda.Threads));
foreach (var thread in borda.Threads)
{
var unpackedThread = unpackedBorda.Threads
.SingleOrDefault(x => x.CompareTo(thread) == 0);
Assert.NotNull(unpackedThread);
Assert.True(thread.Messages.Count == unpackedThread.Messages.Count);
foreach (var message in thread.Messages)
{
Assert.True(unpackedThread.Messages
.Any(x => x.Body == message.Body));
}
}
}
}
}
private static void PackRequest( Packer packer, string id )
{
packer.PackArrayHeader( 4 );
packer.Pack( 0 );
packer.Pack( 1 );
packer.PackString( "Test" );
packer.PackArrayHeader( 1 );
packer.PackString( id );
}
protected override void PackToCoreOverride(Packer packer, object objectTree)
{
packer.PackArrayHeader(this.MemberSerializers.Length);
for (int i = 0; i < this.MemberSerializers.Length; i++)
{
this.MemberSerializers[i].PackTo(packer, this.MemberGetters[i](objectTree));
}
}
private static void PackValuesAsArray(
Packer packer,
MessagePackObject memberDefault,
MessagePackObject nullButValueType,
MessagePackObject nullAndNullableValueType,
MessagePackObject nullAndReferenceType,
MessagePackObject prohibitReferenceType
)
{
packer.PackArrayHeader( 5 );
packer.Pack( memberDefault );
packer.Pack( nullButValueType );
packer.Pack( nullAndNullableValueType );
packer.Pack( nullAndReferenceType );
packer.Pack( prohibitReferenceType );
}
public void ChangeFile()
{
var packer = new Packer();
lock (OutputFileLock)
{
if (File.Exists(destFile))
File.Delete(destFile);
var key = TestDataProvider.RandomText();
packer.Pack(TestDataProvider.RandomBorda(), key, sourceFile, destFile);
var srcHash = CalculateMD5(sourceFile);
var dstHash = CalculateMD5(destFile);
Assert.False(srcHash.SequenceEqual(dstHash));
File.Delete(destFile);
}
}
private static void PackValuesAsMap(
Packer packer,
MessagePackObject memberDefault,
MessagePackObject nullButValueType,
MessagePackObject nullAndNullableValueType,
MessagePackObject nullAndReferenceType,
MessagePackObject prohibitReferenceType
)
{
packer.PackMapHeader( 5 );
packer.PackString( "MemberDefault" );
packer.Pack( memberDefault );
packer.PackString( "NullButValueType" );
packer.Pack( nullButValueType );
packer.PackString( "NullAndNullableValueType" );
packer.Pack( nullAndNullableValueType );
packer.PackString( "NullAndReferenceType" );
packer.Pack( nullAndReferenceType );
packer.PackString( "ProhibitReferenceType" );
packer.Pack( prohibitReferenceType );
}
/// <summary>
/// Clears the buffers to deserialize message, which is not required to dispatch and invoke server method.
/// </summary>
internal override void ClearBuffers()
{
if ( this.ArgumentsBufferUnpacker != null )
{
this.ArgumentsBufferUnpacker.Dispose();
this.ArgumentsBufferUnpacker = null;
}
if ( this.ArgumentsBufferPacker != null )
{
this.ArgumentsBufferPacker.Dispose();
this.ArgumentsBufferPacker = null;
}
this.ArgumentsCount = 0;
this.UnpackedArgumentsCount = 0;
base.ClearBuffers();
}
/// <summary> /// Serializes specified object with specified <see cref="Packer"/>. /// </summary> /// <param name="packer"><see cref="Packer"/> which packs values in <paramref name="objectTree"/>. This value will not be <c>null</c>.</param> /// <param name="objectTree">Object to be serialized.</param> /// <exception cref="SerializationException"> /// The type of <paramref name="objectTree" /> is not serializable etc. /// </exception> protected internal abstract void PackToCore( Packer packer, object objectTree );
protected internal sealed override void PackToCore(Packer packer, System.Byte value)
{
packer.Pack(value);
}
public static Dictionary <string, Texture2D> CreateAlphaAtlasTexture()
{
Dictionary <string, Texture2D> result = new Dictionary <string, Texture2D>();
List <Entry> entries = new List <Entry>();
Material mat = new Material(Shader.Find("Unlit/Transparent"));
List <UnityEngine.Object> objects = new List <UnityEngine.Object>();
foreach (string path in AssetDatabase.FindAssets("t:sprite"))
{
objects.AddRange(AssetDatabase.LoadAllAssetRepresentationsAtPath(AssetDatabase.GUIDToAssetPath(path)));
}
Sprite[] sprites = objects.Distinct()
.Select(x => x as Sprite)
.Where(x => x != null && x.packed)
.ToArray();
foreach (Sprite sprite in sprites)
{
string atlasName;
Texture2D atlasTexture;
Packer.GetAtlasDataForSprite(sprite, out atlasName, out atlasTexture);
Texture2D texture = SpriteUtility.GetSpriteTexture(sprite, false);
if (atlasTexture != null && texture != null && texture.format == TextureFormat.RGBA32)
{
entries.Add(new Entry()
{
sprite = sprite,
atlasName = atlasName,
texture = texture,
atlasTexture = atlasTexture,
uvs = SpriteUtility.GetSpriteUVs(sprite, false),
atlasUvs = SpriteUtility.GetSpriteUVs(sprite, true),
});
}
}
var atlasGroups =
from e in entries
group e by e.atlasTexture;
foreach (var atlasGroup in atlasGroups)
{
Texture tex = atlasGroup.Key;
RenderTexture rt = RenderTexture.GetTemporary(tex.width, tex.height, 0, RenderTextureFormat.ARGB32);
Graphics.SetRenderTarget(rt);
GL.Clear(true, true, Color.clear);
GL.PushMatrix();
GL.LoadOrtho();
foreach (var entry in atlasGroup)
{
mat.mainTexture = entry.texture;
mat.SetPass(0);
GL.Begin(GL.TRIANGLES);
var tris = entry.sprite.triangles;
foreach (int index in tris)
{
GL.TexCoord(entry.uvs[index]);
GL.Vertex(entry.atlasUvs[index]);
}
GL.End();
}
GL.PopMatrix();
Texture2D tex2 = new Texture2D(tex.width, tex.height, TextureFormat.RGBA32, false);
tex2.ReadPixels(new Rect(0, 0, tex.width, tex.height), 0, 0);
var colors = tex2.GetPixels32();
int count = colors.Length;
Color32[] newColors = new Color32[count];
for (int i = 0; i < count; i++)
{
byte alpha = colors[i].a;
newColors[i] = new Color32(alpha, alpha, alpha, 255);
}
tex2.SetPixels32(newColors);
tex2.Apply();
string texName = tex.name;
texName = tex.name.Substring(0, texName.LastIndexOf("-")) + "-fmt32";
result.Add(texName, tex2);
RenderTexture.ReleaseTemporary(rt);
}
return(result);
}
protected override void PackToCore(Packer packer, DateTime objectTree)
{
packer.Pack(objectTree.Ticks);
}
public FluentdEmitter(Stream stream)
{
this.serializationContext = new SerializationContext(PackerCompatibilityOptions.PackBinaryAsRaw);
this.serializationContext.Serializers.Register(new OrdinaryDictionarySerializer());
this.packer = Packer.Create(stream);
}
protected internal sealed override void PackToCore(Packer packer, DateTime value)
{
packer.Pack(MessagePackConvert.FromDateTime(value));
}
protected override void PackToMessageCore(Packer packer)
{
packer.PackArrayHeader(1);
packer.Pack(_str);
}
/// <summary> /// Serialize specified object with specified <see cref="Packer"/>. /// </summary> /// <param name="packer"><see cref="Packer"/> which packs values in <paramref name="objectTree"/>. This value will not be <c>null</c>.</param> /// <param name="objectTree">Object to be serialized.</param> /// <exception cref="SerializationException"> /// <typeparamref name="T"/> is not serializable etc. /// </exception> protected internal abstract void PackToCore(Packer packer, T objectTree);
/// <summary>
/// Serialize specified object to the <see cref="Stream"/>.
/// </summary>
/// <param name="stream">Destination <see cref="Stream"/>.</param>
/// <param name="objectTree">Object to be serialized.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="stream"/> is <c>null</c>.
/// </exception>
/// <exception cref="SerializationException">
/// <typeparamref name="T"/> is not serializable etc.
/// </exception>
public void Pack(Stream stream, T objectTree)
{
this.PackTo(Packer.Create(stream, this._packerCompatibilityOptions), objectTree);
}
protected internal override void PackToCore(Packer packer, T objectTree)
{
this._packToCore(this._context, packer, objectTree);
}
internal abstract void InternalPackTo( Packer packer, object objectTree );
internal abstract Task InternalPackToAsync( Packer packer, object objectTree, CancellationToken cancellationToken );
protected internal override void PackToCore(Packer packer, Complex objectTree)
{
packer.PackArrayHeader(2);
packer.Pack(objectTree.Real);
packer.Pack(objectTree.Imaginary);
}
protected abstract void PackToCoreOverride(Packer packer, object objectTree);
public Packed(byte[] dataArray)
{
owner = null;
stream = null;
data = dataArray;
}
private static void PackValuesAsArray(
Packer packer,
List<int> memberDefault,
List<int> @null,
List<int> prohibit
)
{
packer.PackArrayHeader( 3 );
packer.Pack( memberDefault == null ? default( int[] ) : memberDefault.ToArray() );
packer.Pack( @null == null ? default( int[] ) : @null.ToArray() );
packer.Pack( prohibit == null ? default( int[] ) : prohibit.ToArray() );
}
protected internal sealed override void PackToCore(Packer packer, System.Guid value)
{
packer.PackRaw(value.ToByteArray());
}
private void UpdateCache()
{
// unpack cache.psarc
const int numSteps = 8; // max number of times ReportProgress will be called
var step = (int)Math.Round(1.0 / (numSteps + 2) * 100, 0);
int progress = 0;
progress += step;
ProcessStarted(progress, "Unpacking cache file ... ");
var srcPath = Path.Combine(rsDir, "cache.psarc");
var destPath = Path.Combine(rsDir, "cache.psarc.org");
// backup the original cache.psarc and never overwrite it
if (!File.Exists(destPath))
{
File.Copy(srcPath, destPath, false);
}
var tmpCisDir = Path.Combine(tmpWorkDir, "cis_cache");
if (Directory.Exists(tmpCisDir))
{
DirectoryExtension.SafeDelete(tmpCisDir, true);
}
// CRITCAL PATH
Directory.CreateDirectory(Path.Combine(tmpCisDir, "cache4\\gfxassets\\views"));
destPath = tmpCisDir;
Packer.Unpack(srcPath, destPath);
// ExternalApps.UnpackPsarc(srcPath, destPath, DLCInlayCreator.GlobalTitlePlatform);
// convert user png images to dds images
for (int i = 0; i < 5; i++)
{
progress += step;
ProcessStarted(progress, "Converting user PNG images ...");
if (imageArray[i, 3] != null) // user has specified a replacement image
{
// CRITICAL PATH AND ARGS
srcPath = imageArray[i, 3];
destPath = Path.Combine(tmpCisDir, "cache4\\gfxassets\\views", Path.GetFileName(imageArray[i, 2]));
ExternalApps.Png2Dds(srcPath, destPath, ImageHandler.Size2IntX(imageArray[i, 1]), ImageHandler.Size2IntY(imageArray[i, 1]));
}
}
// update user images to zip file
progress += step;
ProcessStarted(progress, "Injecting user images ...");
// SUPER CRITICAL PATH AND ARGS
var rootDir = string.Format("cache_{0}", DLCInlayCreator.GlobalTitlePlatform);
srcPath = Path.Combine(tmpCisDir, "cache4\\gfxassets");
destPath = Path.Combine(tmpCisDir, rootDir, "cache4.7z");
ExternalApps.InjectZip(srcPath, destPath, true);
// repack cache.psarc
progress += step;
ProcessStarted(progress, "Repacking cache file ...");
srcPath = Path.Combine(tmpCisDir, rootDir);
destPath = Path.Combine(rsDir, "cache.psarc");
Packer.Pack(srcPath, destPath);
// ExternalApps.RepackPsarc(srcPath, destPath, DLCInlayCreator.GlobalTitlePlatform);
ProcessCompleted(null, null);
}
protected internal sealed override void PackToCore(Packer packer, System.Collections.Specialized.BitVector32 value)
{
packer.Pack(value.Data);
}
internal override void ClearBuffers()
{
this._methodNameBuffer.SetLength( 0 );
this._argumentsBuffer.SetLength( 0 );
this.SocketContext.BufferList = null;
this._argumentsPacker.Dispose();
this._argumentsPacker = Packer.Create( this._argumentsBuffer, false );
this.SendingBuffer[ 0 ] = new ArraySegment<byte>();
this.SendingBuffer[ 1 ] = new ArraySegment<byte>();
this.SendingBuffer[ 2 ] = new ArraySegment<byte>();
this.SendingBuffer[ 3 ] = new ArraySegment<byte>();
base.ClearBuffers();
}
protected internal override void WriteBuffer()
{
byte[] functionArgBuffer = null;
int fieldCount = 0;
int filterSize = 0;
int binNameSize = 0;
Begin();
if (statement.ns != null)
{
dataOffset += ByteUtil.EstimateSizeUtf8(statement.ns) + FIELD_HEADER_SIZE;
fieldCount++;
}
if (statement.indexName != null)
{
dataOffset += ByteUtil.EstimateSizeUtf8(statement.indexName) + FIELD_HEADER_SIZE;
fieldCount++;
}
if (statement.setName != null)
{
dataOffset += ByteUtil.EstimateSizeUtf8(statement.setName) + FIELD_HEADER_SIZE;
fieldCount++;
}
// Allocate space for TaskId field.
dataOffset += 8 + FIELD_HEADER_SIZE;
fieldCount++;
if (statement.filters != null)
{
if (statement.filters.Length >= 1)
{
IndexCollectionType type = statement.filters[0].CollectionType;
if (type != IndexCollectionType.DEFAULT)
{
dataOffset += FIELD_HEADER_SIZE + 1;
fieldCount++;
}
}
dataOffset += FIELD_HEADER_SIZE;
filterSize++; // num filters
foreach (Filter filter in statement.filters)
{
filterSize += filter.EstimateSize();
}
dataOffset += filterSize;
fieldCount++;
// Query bin names are specified as a field (Scan bin names are specified later as operations)
if (statement.binNames != null)
{
dataOffset += FIELD_HEADER_SIZE;
binNameSize++; // num bin names
foreach (string binName in statement.binNames)
{
binNameSize += ByteUtil.EstimateSizeUtf8(binName) + 1;
}
dataOffset += binNameSize;
fieldCount++;
}
}
else
{
// Calling query with no filters is more efficiently handled by a primary index scan.
// Estimate scan options size.
dataOffset += 2 + FIELD_HEADER_SIZE;
fieldCount++;
}
if (statement.functionName != null)
{
dataOffset += FIELD_HEADER_SIZE + 1; // udf type
dataOffset += ByteUtil.EstimateSizeUtf8(statement.packageName) + FIELD_HEADER_SIZE;
dataOffset += ByteUtil.EstimateSizeUtf8(statement.functionName) + FIELD_HEADER_SIZE;
if (statement.functionArgs.Length > 0)
{
functionArgBuffer = Packer.Pack(statement.functionArgs);
}
else
{
functionArgBuffer = new byte[0];
}
dataOffset += FIELD_HEADER_SIZE + functionArgBuffer.Length;
fieldCount += 4;
}
if (statement.filters == null)
{
if (statement.binNames != null)
{
foreach (string binName in statement.binNames)
{
EstimateOperationSize(binName);
}
}
}
SizeBuffer();
int operationCount = (statement.filters == null && statement.binNames != null) ? statement.binNames.Length : 0;
WriteQueryHeader(fieldCount, operationCount);
if (statement.ns != null)
{
WriteField(statement.ns, FieldType.NAMESPACE);
}
if (statement.indexName != null)
{
WriteField(statement.indexName, FieldType.INDEX_NAME);
}
if (statement.setName != null)
{
WriteField(statement.setName, FieldType.TABLE);
}
// Write taskId field
WriteFieldHeader(8, FieldType.TRAN_ID);
ByteUtil.LongToBytes((ulong)statement.taskId, dataBuffer, dataOffset);
dataOffset += 8;
if (statement.filters != null)
{
if (statement.filters.Length >= 1)
{
IndexCollectionType type = statement.filters[0].CollectionType;
if (type != IndexCollectionType.DEFAULT)
{
WriteFieldHeader(1, FieldType.INDEX_TYPE);
dataBuffer[dataOffset++] = (byte)type;
}
}
WriteFieldHeader(filterSize, FieldType.INDEX_RANGE);
dataBuffer[dataOffset++] = (byte)statement.filters.Length;
foreach (Filter filter in statement.filters)
{
dataOffset = filter.Write(dataBuffer, dataOffset);
}
// Query bin names are specified as a field (Scan bin names are specified later as operations)
if (statement.binNames != null)
{
WriteFieldHeader(binNameSize, FieldType.QUERY_BINLIST);
dataBuffer[dataOffset++] = (byte)statement.binNames.Length;
foreach (string binName in statement.binNames)
{
int len = ByteUtil.StringToUtf8(binName, dataBuffer, dataOffset + 1);
dataBuffer[dataOffset] = (byte)len;
dataOffset += len + 1;
}
}
}
else
{
// Calling query with no filters is more efficiently handled by a primary index scan.
WriteFieldHeader(2, FieldType.SCAN_OPTIONS);
byte priority = (byte)policy.priority;
priority <<= 4;
dataBuffer[dataOffset++] = priority;
dataBuffer[dataOffset++] = (byte)100;
}
if (statement.functionName != null)
{
WriteFieldHeader(1, FieldType.UDF_OP);
dataBuffer[dataOffset++] = (statement.returnData) ? (byte)1 : (byte)2;
WriteField(statement.packageName, FieldType.UDF_PACKAGE_NAME);
WriteField(statement.functionName, FieldType.UDF_FUNCTION);
WriteField(functionArgBuffer, FieldType.UDF_ARGLIST);
}
// Scan bin names are specified after all fields.
if (statement.filters == null)
{
if (statement.binNames != null)
{
foreach (string binName in statement.binNames)
{
WriteOperation(binName, Operation.Type.READ);
}
}
}
End();
}
protected internal sealed override void PackToCore(Packer packer, System.TimeSpan value)
{
packer.Pack(value.Ticks);
}
protected internal override void PackToCore(Packer packer, TestValueTypeWrapper objectTree)
{
packer.PackArrayHeader(1);
this._serializer0.PackTo(packer, objectTree.Value);
}
protected internal sealed override void PackToCore(Packer packer, System.Numerics.BigInteger value)
{
packer.PackRaw(value.ToByteArray());
}
protected internal override void PackToCore(Packer packer, DateTime objectTree)
{
packer.Pack(MessagePackConvert.FromDateTime(objectTree));
}
internal override void InternalPackTo( Packer packer, object objectTree )
{
// TODO: Hot-Path-Optimization
if ( packer == null )
{
throw new ArgumentNullException( "packer" );
}
// ReSharper disable once CompareNonConstrainedGenericWithNull
if ( objectTree == null )
{
packer.PackNull();
return;
}
this.PackToCore( packer, objectTree );
}
protected internal override Task PackToAsyncCore(Packer packer, DateTime objectTree, CancellationToken cancellationToken)
{
return(packer.PackAsync(MessagePackConvert.FromDateTime(objectTree), cancellationToken));
}
protected internal override void PackToCore(Packer packer, object objectTree)
{
this._packToCore(packer, objectTree, this._keySerializer, this._valueSerializer);
}
public static void PackCharArraySegmentTo(Packer packer, ArraySegment <char> objectTree, MessagePackSerializer <char> itemSerializer)
{
// TODO: More efficient
packer.PackStringHeader(objectTree.Count);
packer.PackRawBody(MessagePackConvert.EncodeString(new string( objectTree.Array.Skip(objectTree.Offset).Take(objectTree.Count).ToArray())));
}
/// <summary>
/// Serialize specified object with specified <see cref="Packer" />.
/// </summary>
/// <param name="packer"><see cref="Packer" /> which packs values in <paramref name="objectTree" />.</param>
/// <param name="objectTree">Object to be serialized.</param>
/// <seealso cref="Capabilities" />
public void PackTo( Packer packer, object objectTree )
{
this.InternalPackTo( packer, objectTree );
}
public void Pack(Packer packer)
{
packer.Pack(IndexData);
}
public Task PackToAsync( Packer packer, object objectTree, CancellationToken cancellationToken )
{
return this.InternalPackToAsync( packer, objectTree, cancellationToken );
}
private int ApplyPackageDD(string file, string remSUS, string rampPath, string cfgPath, out string consoleOutputPkg, bool keepLog = false)
{
int singleResult = -1;
bool exitedByError = false;
consoleOutputPkg = String.Empty;
var tmpDir = Path.GetTempPath();
var platform = file.GetPlatform();
var unpackedDir = Packer.Unpack(file, tmpDir);
var xmlFiles = Directory.EnumerateFiles(unpackedDir, "*.xml", SearchOption.AllDirectories);
foreach (var xml in xmlFiles)
{
if (Path.GetFileNameWithoutExtension(xml).ToUpperInvariant().Contains("VOCAL"))
{
continue;
}
if (Path.GetFileNameWithoutExtension(xml).ToUpperInvariant().Contains("SHOWLIGHT"))
{
continue;
}
singleResult = ApplyDD(xml, remSUS, rampPath, cfgPath, out consoleOutputPkg, true, keepLog);
if (singleResult == 1)
{
exitedByError = true;
break;
}
else if (singleResult == 2)
{
consoleOutputPkg = String.Format("Arrangement file '{0}' => {1}", Path.GetFileNameWithoutExtension(xml), consoleOutputPkg);
}
}
if (!exitedByError)
{
var logFiles = Directory.EnumerateFiles(unpackedDir, "*.log", SearchOption.AllDirectories);
var newName = Path.Combine(Path.GetDirectoryName(file), String.Format("{0}_{1}{2}",
Path.GetFileNameWithoutExtension(file).StripPlatformEndName().GetValidFileName().Replace("_DD", "").Replace("_NDD", ""),
isNDD ? "NDD" : "DD", platform.GetPathName()[2]));
if (keepLog)
{
string clogDir = Path.Combine(Path.GetDirectoryName(newName), "DDC_Log");
string plogDir = Path.Combine(clogDir, Path.GetFileNameWithoutExtension(newName).StripPlatformEndName().Replace("_DD", "").Replace("_NDD", ""));
if (!Directory.Exists(clogDir))
{
Directory.CreateDirectory(clogDir);
}
DirectoryExtension.SafeDelete(plogDir); Directory.CreateDirectory(plogDir);
foreach (var logFile in logFiles)
{
File.Move(logFile, Path.Combine(plogDir, Path.GetFileName(logFile)));
}
}
else
{
foreach (var logFile in logFiles.Where(File.Exists))
{
File.Delete(logFile);
}
}
Packer.Pack(unpackedDir, newName, true, platform, true);
DirectoryExtension.SafeDelete(unpackedDir);
}
return(singleResult);
}
protected internal override void PackToCore(Packer packer, object objectTree)
{
this._packToCore(packer, objectTree, this._elementSerializer);
}
/// <summary>
/// Saves the project as XML document.
/// </summary>
/// <returns>The serialized project XML.</returns>
public XmlDocument Save()
{
var xmlDoc = new XmlDocument();
xmlDoc.Schemas.Add(Schema);
XmlElement elem = xmlDoc.CreateElement("project", Namespace);
XmlAttribute outputAttr = xmlDoc.CreateAttribute("outputDir");
outputAttr.Value = OutputDirectory;
elem.Attributes.Append(outputAttr);
XmlAttribute baseAttr = xmlDoc.CreateAttribute("baseDir");
baseAttr.Value = BaseDirectory;
elem.Attributes.Append(baseAttr);
if (Seed != null)
{
XmlAttribute seedAttr = xmlDoc.CreateAttribute("seed");
seedAttr.Value = Seed;
elem.Attributes.Append(seedAttr);
}
if (Debug)
{
XmlAttribute debugAttr = xmlDoc.CreateAttribute("debug");
debugAttr.Value = Debug.ToString().ToLower();
elem.Attributes.Append(debugAttr);
}
foreach (Rule i in Rules)
{
elem.AppendChild(i.Save(xmlDoc));
}
if (Packer != null)
{
elem.AppendChild(Packer.Save(xmlDoc));
}
foreach (ProjectModule i in this)
{
elem.AppendChild(i.Save(xmlDoc));
}
foreach (string i in ProbePaths)
{
XmlElement path = xmlDoc.CreateElement("probePath", Namespace);
path.InnerText = i;
elem.AppendChild(path);
}
foreach (string i in PluginPaths)
{
XmlElement path = xmlDoc.CreateElement("plugin", Namespace);
path.InnerText = i;
elem.AppendChild(path);
}
xmlDoc.AppendChild(elem);
return(xmlDoc);
}
protected internal sealed override void PackToCore(Packer packer, object objectTree)
{
if (this._packToMessage != null)
{
this._packToMessage(objectTree, packer, null);
}
else
{
this.PackToCoreOverride(packer, objectTree);
}
}
protected internal override void PackToCore(Packer packer, Dictionary <TKey, TValue> objectTree)
{
PackerUnpackerExtensions.PackDictionaryCore(packer, objectTree, this._keySerializer, this._valueSerializer);
}
public void PackTo(Packer packer, object objectTree)
{
if (packer == null)
{
throw new ArgumentNullException("packer");
}
Contract.EndContractBlock();
packer.PackNull();
}
protected internal override void PackToCore(Packer packer, TList objectTree)
protected override void PackToCore(Packer packer, Capability objectTree)
{
packer.Pack(objectTree.ToJson());
}
/// <summary>
/// Initializes a new instance of MsgPack.Packer
/// </summary>
/// <param name="stream">Stream object to be wrapped by the Packer</param>
public FluentdPacker(Stream stream)
{
this.packer = Packer.Create(stream);
}
private static void PackValuesAsMap(
Packer packer,
List<int> memberDefault,
List<int> @null,
List<int> prohibit
)
{
packer.PackMapHeader( 3 );
packer.PackString( "MemberDefault" );
packer.Pack( memberDefault == null ? default( int[] ) : memberDefault.ToArray() );
packer.PackString( "Null" );
packer.Pack( @null == null ? default( int[] ) : @null.ToArray() );
packer.PackString( "Prohibit" );
packer.Pack( prohibit == null ? default( int[] ) : prohibit.ToArray() );
}
protected internal override void PackToCore(Packer packer, T objectTree)
{
this._packToCore(packer, objectTree, this._elementSerializer);
}
private static void PackNotify( Packer packer, string id )
{
packer.PackArrayHeader( 3 );
packer.Pack( 2 );
packer.PackString( "Test" );
packer.PackArrayHeader( 1 );
packer.PackString( id );
}
protected internal override void PackToCore(Packer packer, TCollection objectTree)
public Packed(Packer owner, MemoryStream stream)
{
this.owner = owner;
this.stream = stream;
this.data = null;
}
protected internal sealed override void PackToCore(Packer packer, System.Decimal value)
{
packer.PackString(value.ToString("G", CultureInfo.InvariantCulture));
}
private Packed(SerializationInfo info, StreamingContext context)
{
owner = null;
stream = null;
data = (byte[])info.GetValue("data", typeof(byte[]));
}
/// <summary>
/// Initializes a new instance of the <see cref="ClientRequestContext"/> class with specified configuration.
/// </summary>
/// <param name="configuration">
/// An <see cref="RpcClientConfiguration"/> to tweak this instance initial state.
/// </param>
public ClientRequestContext( RpcClientConfiguration configuration )
{
this._methodNameBuffer =
new MemoryStream( ( configuration ?? RpcClientConfiguration.Default ).InitialMethodNameBufferLength );
this._argumentsBuffer =
new MemoryStream( ( configuration ?? RpcClientConfiguration.Default ).InitialArgumentsBufferLength );
this.SendingBuffer = new ArraySegment<byte>[ 4 ];
#if MONO
this._unifiedSendingBuffer = new MemoryStream( ( configuration ?? RpcClientConfiguration.Default ).InitialReceiveBufferLength );
#endif
this._argumentsPacker = Packer.Create( this._argumentsBuffer, false );
this._messageType = MessageType.Response;
this._stopwatch = new Stopwatch();
}
