private void GetOutputSatellites(PublishInfo[] publishInfos, ref List <ITaskItem> assemblyList)
{
FileMap satelliteMap = new FileMap();
if (_satelliteAssemblies != null)
{
foreach (ITaskItem item in _satelliteAssemblies)
{
item.SetMetadata("AssemblyType", "Satellite");
satelliteMap.Add(item, true);
}
}
// Apply PublishInfo state from PublishFile items...
foreach (PublishInfo publishInfo in publishInfos)
{
string key = publishInfo.key + ".dll";
MapEntry entry = satelliteMap[key];
if (entry != null)
{
entry.publishInfo = publishInfo;
}
else
{
Log.LogWarningWithCodeFromResources("ResolveManifestFiles.PublishFileNotFound", publishInfo.key);
}
}
// Go through the AssemblyMap and determine which items get added to ouput SatelliteList based
// on computed PublishFlags for each item...
foreach (MapEntry entry in satelliteMap)
{
// If PublishInfo didn't come from a PublishFile item, then construct PublishInfo from the item
if (entry.publishInfo == null)
{
entry.publishInfo = new PublishInfo();
}
CultureInfo satelliteCulture = GetItemCulture(entry.item);
PublishFlags flags = PublishFlags.GetSatelliteFlags(entry.publishInfo.state, satelliteCulture, _targetCulture, _includeAllSatellites);
if (flags.IsPublished &&
string.Equals(entry.publishInfo.includeHash, "false", StringComparison.OrdinalIgnoreCase) &&
SigningManifests == true)
{
_canPublish = false;
}
if (flags.IsPublished)
{
assemblyList.Add(CreateAssemblyItem(entry.item, entry.publishInfo.group, entry.publishInfo.targetPath, entry.publishInfo.includeHash));
}
else if (flags.IsPrerequisite)
{
assemblyList.Add(CreatePrerequisiteItem(entry.item));
}
}
}
private ITaskItem[] GetOutputFiles(PublishInfo[] publishInfos)
{
List <ITaskItem> list = new List <ITaskItem>();
FileMap map = new FileMap();
if (this.Files != null)
{
foreach (ITaskItem item in this.Files)
{
map.Add(item, true);
}
}
if (this.ExtraFiles != null)
{
foreach (ITaskItem item2 in this.ExtraFiles)
{
map.Add(item2, false);
}
}
foreach (PublishInfo info in publishInfos)
{
MapEntry entry = map[info.key];
if (entry != null)
{
entry.publishInfo = info;
}
else
{
base.Log.LogWarningWithCodeFromResources("ResolveManifestFiles.PublishFileNotFound", new object[] { info.key });
}
}
foreach (MapEntry entry2 in (IEnumerable)map)
{
if (entry2.publishInfo == null)
{
entry2.publishInfo = new PublishInfo();
}
string extension = Path.GetExtension(entry2.item.ItemSpec);
PublishFlags flags = PublishFlags.GetFileFlags(entry2.publishInfo.state, extension, entry2.includedByDefault);
if ((flags.IsPublished && string.Equals(entry2.publishInfo.includeHash, "false", StringComparison.OrdinalIgnoreCase)) && this.SigningManifests)
{
this.canPublish = false;
}
if (flags.IsPublished)
{
list.Add(CreateFileItem(entry2.item, entry2.publishInfo.group, entry2.publishInfo.targetPath, entry2.publishInfo.includeHash, flags.IsDataFile));
}
}
return(list.ToArray());
}
public void AddRecord(int iface, Protocol proto, PublishFlags flags, string name,
RecordClass clazz, RecordType type, uint ttl, byte[] rdata, int length)
{
lock (client) {
int ret = avahi_entry_group_add_record(handle, iface, proto, flags,
Utility.StringToBytes(name),
clazz, type, ttl, rdata, length);
if (ret < 0)
{
client.ThrowError();
}
}
}
public void UpdateService(int iface, Protocol proto, PublishFlags flags, string name, string type,
string domain, params byte[][] txt)
{
IntPtr list = avahi_string_list_new(IntPtr.Zero);
if (txt != null)
{
foreach (byte[] item in txt)
{
list = avahi_string_list_add(list, item);
}
}
UpdateService(iface, proto, flags, name, type, domain, list);
}
public void AddService(int iface, Protocol proto, PublishFlags flags, string name, string type, string domain,
string host, UInt16 port, params string[] txt)
{
IntPtr list = avahi_string_list_new(IntPtr.Zero);
if (txt != null)
{
foreach (string item in txt)
{
list = avahi_string_list_add(list, Utility.StringToBytes(item));
}
}
AddService(iface, proto, flags, name, type, domain, host, port, list);
}
public void AddAddress(int iface, Protocol proto, PublishFlags flags, string name, IPAddress address)
{
IntPtr addressPtr = Utility.AddressToPtr(address);
lock (client) {
int ret = avahi_entry_group_add_address(handle, iface, proto, flags,
Utility.StringToBytes(name), addressPtr);
Utility.Free(addressPtr);
if (ret < 0)
{
client.ThrowError();
}
}
}
public void AddServiceSubtype(int iface, Protocol proto, PublishFlags flags, string name,
string type, string domain, string subtype)
{
lock (client) {
int ret = avahi_entry_group_add_service_subtype(handle, iface, proto, flags,
Utility.StringToBytes(name),
Utility.StringToBytes(type),
Utility.StringToBytes(domain),
Utility.StringToBytes(subtype));
if (ret < 0)
{
client.ThrowError();
}
}
}
private void GetOutputSatellites(PublishInfo[] publishInfos, ref List <ITaskItem> assemblyList)
{
FileMap map = new FileMap();
if (this.satelliteAssemblies != null)
{
foreach (ITaskItem item in this.satelliteAssemblies)
{
item.SetMetadata("AssemblyType", "Satellite");
map.Add(item, true);
}
}
foreach (PublishInfo info in publishInfos)
{
string str = info.key + ".dll";
MapEntry entry = map[str];
if (entry != null)
{
entry.publishInfo = info;
}
else
{
base.Log.LogWarningWithCodeFromResources("ResolveManifestFiles.PublishFileNotFound", new object[] { info.key });
}
}
foreach (MapEntry entry2 in (IEnumerable)map)
{
if (entry2.publishInfo == null)
{
entry2.publishInfo = new PublishInfo();
}
CultureInfo itemCulture = GetItemCulture(entry2.item);
PublishFlags flags = PublishFlags.GetSatelliteFlags(entry2.publishInfo.state, itemCulture, this.targetCulture, this.includeAllSatellites);
if ((flags.IsPublished && string.Equals(entry2.publishInfo.includeHash, "false", StringComparison.OrdinalIgnoreCase)) && this.SigningManifests)
{
this.canPublish = false;
}
if (flags.IsPublished)
{
assemblyList.Add(CreateAssemblyItem(entry2.item, entry2.publishInfo.group, entry2.publishInfo.targetPath, entry2.publishInfo.includeHash));
}
else if (flags.IsPrerequisite)
{
assemblyList.Add(CreatePrerequisiteItem(entry2.item));
}
}
}
private void UpdateService(int iface, Protocol proto, PublishFlags flags, string name, string type,
string domain, IntPtr list)
{
lock (client) {
int ret = avahi_entry_group_update_service_strlst(handle, iface, proto, flags,
Utility.StringToBytes(name),
Utility.StringToBytes(type),
Utility.StringToBytes(domain),
list);
avahi_string_list_free(list);
if (ret < 0)
{
client.ThrowError();
}
}
}
private void AddService(int iface, Protocol proto, PublishFlags flags, string name, string type,
string domain, string host, UInt16 port, IntPtr list)
{
int ret;
lock (client) {
ret = avahi_entry_group_add_service_strlst(handle, iface, proto, flags,
Utility.StringToBytes(name),
Utility.StringToBytes(type),
Utility.StringToBytes(domain),
Utility.StringToBytes(host), port, list);
}
avahi_string_list_free(list);
if (ret < 0)
{
client.ThrowError();
}
}
public void UpdateService(int iface, Protocol proto, PublishFlags flags, string name, string type,
string domain, params byte[][] txt)
{
IntPtr list = avahi_string_list_new (IntPtr.Zero);
if (txt != null) {
foreach (byte[] item in txt) {
list = avahi_string_list_add (list, item);
}
}
UpdateService (iface, proto, flags, name, type, domain, list);
}
public void AddServiceSubtype(int iface, Protocol proto, PublishFlags flags, string name,
string type, string domain, string subtype)
{
lock (client) {
int ret = avahi_entry_group_add_service_subtype (handle, iface, proto, flags,
Utility.StringToBytes (name),
Utility.StringToBytes (type),
Utility.StringToBytes (domain),
Utility.StringToBytes (subtype));
if (ret < 0) {
client.ThrowError ();
}
}
}
public void AddService(int iface, Protocol proto, PublishFlags flags, string name, string type, string domain,
string host, UInt16 port, params string[] txt)
{
IntPtr list = avahi_string_list_new (IntPtr.Zero);
if (txt != null) {
foreach (string item in txt) {
list = avahi_string_list_add (list, Utility.StringToBytes (item));
}
}
AddService (iface, proto, flags, name, type, domain, host, port, list);
}
public void AddService(PublishFlags flags, string name, string type, string domain,
UInt16 port, params string[] txt)
{
AddService (-1, Protocol.Unspecified, flags, name, type, domain, null, port, txt);
}
public void AddRecord(int iface, Protocol proto, PublishFlags flags, string name,
RecordClass clazz, RecordType type, uint ttl, byte[] rdata, int length)
{
lock (client) {
int ret = avahi_entry_group_add_record (handle, iface, proto, flags,
Utility.StringToBytes (name),
clazz, type, ttl, rdata, length);
if (ret < 0) {
client.ThrowError ();
}
}
}
public void AddService(PublishFlags flags, string name, string type, string domain,
UInt16 port, params string[] txt)
{
AddService(-1, Protocol.Unspecified, flags, name, type, domain, null, port, txt);
}
private static extern int avahi_entry_group_add_service_subtype(IntPtr group, int iface, Protocol proto,
PublishFlags flags, byte[] name, byte[] type,
byte[] domain, byte[] subtype);
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
foreach (string publishFlag in Settings.SupportedAvailabilities)
{
PublishFlags.Add(publishFlag);
}
// Add our command handlers for menu (commands must exist in the .vsct file)
var mcs = GetService(typeof(IMenuCommandService)) as IMenuCommandService;
if (mcs != null)
{
var rdt = GetService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable;
var ms = GetService(typeof(SVsShellMonitorSelection)) as IVsMonitorSelection;
var componentModel = GetService(typeof(SComponentModel)) as IComponentModel;
var shell = GetService(typeof(SVsUIShell)) as IVsUIShell;
shell.UpdateCommandUI(1);
rdtm = new UDNDocRunningTableMonitor(rdt, ms, componentModel.GetService <IVsEditorAdaptersFactoryService>(), shell, this);
uint cookie;
rdt.AdviseRunningDocTableEvents(rdtm, out cookie);
// Create the command for the tool window
CommandID publishRecursiveCmdID = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.CmdidMarkdownPublishRecursiveCtxt);
OleMenuCommand publishRecursiveSlnExpCommand = new OleMenuCommand(new EventHandler((sender, e) => PublishSelectedDocuments(sender, e, true)), publishRecursiveCmdID);
AddSolutionExplorerCommand(mcs, publishRecursiveSlnExpCommand, rdtm);
CommandID publishCommandID = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownPublishPagesCtxt);
OleMenuCommand publishCommand = new OleMenuCommand(new EventHandler((sender, e) => PublishSelectedDocuments(sender, e, false)), publishCommandID);
AddSolutionExplorerCommand(mcs, publishCommand, rdtm);
CommandID publishPreviewCommandID = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownPreviewPage);
OleMenuCommand publishPreviewCommand = new OleMenuCommand(new EventHandler((sender, e) => PublishOrPreviewPage(sender, e, " -p")), publishPreviewCommandID);
AddCommandWithEnableFlag(mcs, publishPreviewCommand, rdtm);
CommandID publishPageCommandID = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownPublishPage);
OleMenuCommand publishPageCommand = new OleMenuCommand(new EventHandler((sender, e) => PublishOrPreviewPage(sender, e, "")), publishPageCommandID);
AddCommandWithEnableFlag(mcs, publishPageCommand, rdtm);
CommandID publishRecursiveCommandID = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownPublishRecursive);
OleMenuCommand publishRecursiveCommand = new OleMenuCommand(new EventHandler(PublishRecursive), publishRecursiveCommandID);
AddCommandWithEnableFlag(mcs, publishRecursiveCommand, rdtm);
CommandID SetTextToBoldCommandID = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownBoldText);
OleMenuCommand SetTextToBoldCommand = new OleMenuCommand(new EventHandler((sender, e) => SetTextStyle(sender, e, "**")), SetTextToBoldCommandID);
AddCommandWithEnableFlag(mcs, SetTextToBoldCommand, rdtm);
CommandID SetTextToItalicsCommandID = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownItalicText);
OleMenuCommand SetTextToItalicCommand = new OleMenuCommand(new EventHandler((sender, e) => SetTextStyle(sender, e, "_")), SetTextToItalicsCommandID);
AddCommandWithEnableFlag(mcs, SetTextToItalicCommand, rdtm);
CommandID SetTextToCodeCommandID = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownCodeText);
OleMenuCommand SetTextToCodeCommand = new OleMenuCommand(new EventHandler((sender, e) => SetTextStyle(sender, e, "`")), SetTextToCodeCommandID);
AddCommandWithEnableFlag(mcs, SetTextToCodeCommand, rdtm);
// Create the command for the tool window
var showPreviewWindowCommandId = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownPreviewWindow);
var showPreviewWindowCommand = new OleMenuCommand(ShowToolWindow, showPreviewWindowCommandId);
AddCommandWithEnableFlag(mcs, showPreviewWindowCommand, rdtm);
var openImagesCommandId = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownOpenImagesFolder);
var openImagesCommand = new OleMenuCommand(OpenImageFolder, openImagesCommandId);
AddCommandWithEnableFlag(mcs, openImagesCommand, rdtm);
var navigateToComboCommandId = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownNavigateToCombo);
var navigateToCombo = new OleMenuCommand(NavigateToComboSelected, navigateToComboCommandId);
AddCommandWithEnableFlag(mcs, navigateToCombo, rdtm);
var navigateToComboGetListCommandId = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownNavigateToComboGetList);
var navigateToComboGetListCmd = new OleMenuCommand(NavigateToComboGetList, navigateToComboGetListCommandId);
AddCommandWithEnableFlag(mcs, navigateToComboGetListCmd, rdtm);
InitializePublishFlagButtons(mcs, rdtm);
var rebuildDoxygenCommandId = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownRebuildDoxygenDatabase);
var rebuildDoxygenCommand = new OleMenuCommand(RebuildDoxygen, rebuildDoxygenCommandId);
AddCommandWithEnableFlag(mcs, rebuildDoxygenCommand, rdtm);
var checkP4ImagesCommandId = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownCheckP4Images);
var checkP4ImagesCommand = new OleMenuCommand(CheckP4Images, checkP4ImagesCommandId);
AddCommandWithEnableFlag(mcs, checkP4ImagesCommand, rdtm);
var disableParsingCommandId = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownDisableParsing);
var disableParsingCommand = new OleMenuCommand(DisableDocumentParsing, disableParsingCommandId);
AddCommandWithEnableFlag(mcs, disableParsingCommand, rdtm);
var disableHighlightingCommandId = new CommandID(GuidList.guidMarkdownPackageCmdSet, PkgCmdId.cmdidMarkdownDisableHighlighting);
var disableHighlightingCommand = new OleMenuCommand(DisableHighlightingMode, disableHighlightingCommandId);
AddCommandWithEnableFlag(mcs, disableHighlightingCommand, rdtm);
}
Action reloadSettings = () =>
{
string newDoxygenXmlPath = null;
if (!string.IsNullOrEmpty(GetOptions().DoxygenXmlCachePath))
{
newDoxygenXmlPath = GetOptions().DoxygenXmlCachePath;
}
DoxygenHelper.DoxygenXmlPath = newDoxygenXmlPath;
FileInfo newDoxygenExec = null;
if (!string.IsNullOrEmpty(GetOptions().DoxygenBinaryPath))
{
var doxygenExec = new FileInfo(GetOptions().DoxygenBinaryPath);
if (doxygenExec.Exists)
{
newDoxygenExec = doxygenExec;
}
}
DoxygenHelper.DoxygenExec = newDoxygenExec;
};
Action loadLastPublishingOptions = () =>
{
if (!Settings.Default.FirstRun)
{
PublishFlags.Clear();
if (Settings.Default.LastAvailability != "")
{
var lastSettings = Settings.Default.LastAvailability.Split(',');
foreach (string lastSetting in lastSettings)
{
PublishFlags.Add(lastSetting);
}
}
}
else
{
PublishFlags.Clear();
Settings.Default.FirstRun = false;
Settings.Default.Save();
}
};
GetOptions().Changed += () => reloadSettings();
reloadSettings();
loadLastPublishingOptions();
}
private void GetOutputAssemblies(PublishInfo[] publishInfos, ref List <ITaskItem> assemblyList)
{
AssemblyMap assemblyMap = new AssemblyMap();
// Add all managed assemblies to the AssemblyMap, except assemblies that are part of the .NET Framework...
if (_managedAssemblies != null)
{
foreach (ITaskItem item in _managedAssemblies)
{
if (!IsFiltered(item))
{
item.SetMetadata("AssemblyType", "Managed");
assemblyMap.Add(item);
}
}
}
if (_nativeAssemblies != null)
{
foreach (ITaskItem item in _nativeAssemblies)
{
if (!IsFiltered(item))
{
item.SetMetadata("AssemblyType", "Native");
assemblyMap.Add(item);
}
}
}
// Apply PublishInfo state from PublishFile items...
foreach (PublishInfo publishInfo in publishInfos)
{
MapEntry entry = assemblyMap[publishInfo.key];
if (entry != null)
{
entry.publishInfo = publishInfo;
}
else
{
Log.LogWarningWithCodeFromResources("ResolveManifestFiles.PublishFileNotFound", publishInfo.key);
}
}
// Go through the AssemblyMap and determine which items get added to ouput AssemblyList based
// on computed PublishFlags for each item...
foreach (MapEntry entry in assemblyMap)
{
// If PublishInfo didn't come from a PublishFile item, then construct PublishInfo from the item
if (entry.publishInfo == null)
{
entry.publishInfo = new PublishInfo();
}
// If state is auto then also need to look on the item to see whether the dependency type
// has alread been specified upstream (i.e. from ResolveNativeReference task)...
if (entry.publishInfo.state == PublishState.Auto)
{
string dependencyType = entry.item.GetMetadata("DependencyType");
if (String.Equals(dependencyType, "Prerequisite", StringComparison.Ordinal))
{
entry.publishInfo.state = PublishState.Prerequisite;
}
else if (String.Equals(dependencyType, "Install", StringComparison.Ordinal))
{
entry.publishInfo.state = PublishState.Include;
}
}
bool copyLocal = GetItemCopyLocal(entry.item);
PublishFlags flags = PublishFlags.GetAssemblyFlags(entry.publishInfo.state, copyLocal);
if (flags.IsPublished &&
string.Equals(entry.publishInfo.includeHash, "false", StringComparison.OrdinalIgnoreCase) &&
SigningManifests == true)
{
_canPublish = false;
}
if (flags.IsPublished)
{
assemblyList.Add(CreateAssemblyItem(entry.item, entry.publishInfo.group, entry.publishInfo.targetPath, entry.publishInfo.includeHash));
}
else if (flags.IsPrerequisite)
{
assemblyList.Add(CreatePrerequisiteItem(entry.item));
}
}
}
private ITaskItem[] GetOutputFiles(PublishInfo[] publishInfos)
{
List <ITaskItem> fileList = new List <ITaskItem>();
FileMap fileMap = new FileMap();
// Add all input Files to the FileMap, flagging them to be published by default...
if (Files != null)
{
foreach (ITaskItem item in Files)
{
fileMap.Add(item, true);
}
}
// Add all input ExtraFiles to the FileMap, flagging them to NOT be published by default...
if (ExtraFiles != null)
{
foreach (ITaskItem item in ExtraFiles)
{
fileMap.Add(item, false);
}
}
// Apply PublishInfo state from PublishFile items...
foreach (PublishInfo publishInfo in publishInfos)
{
MapEntry entry = fileMap[publishInfo.key];
if (entry != null)
{
entry.publishInfo = publishInfo;
}
else
{
Log.LogWarningWithCodeFromResources("ResolveManifestFiles.PublishFileNotFound", publishInfo.key);
}
}
// Go through the FileMap and determine which items get added to ouput FileList based
// on computed PublishFlags for each item...
foreach (MapEntry entry in fileMap)
{
// If PublishInfo didn't come from a PublishFile item, then construct PublishInfo from the item
if (entry.publishInfo == null)
{
entry.publishInfo = new PublishInfo();
}
string fileExtension = Path.GetExtension(entry.item.ItemSpec);
PublishFlags flags = PublishFlags.GetFileFlags(entry.publishInfo.state, fileExtension, entry.includedByDefault);
if (flags.IsPublished &&
string.Equals(entry.publishInfo.includeHash, "false", StringComparison.OrdinalIgnoreCase) &&
SigningManifests == true)
{
_canPublish = false;
}
if (flags.IsPublished)
{
fileList.Add(CreateFileItem(entry.item, entry.publishInfo.group, entry.publishInfo.targetPath, entry.publishInfo.includeHash, flags.IsDataFile));
}
}
return(fileList.ToArray());
}
private void AddService(int iface, Protocol proto, PublishFlags flags, string name, string type,
string domain, string host, UInt16 port, IntPtr list)
{
int ret;
lock (client) {
ret = avahi_entry_group_add_service_strlst (handle, iface, proto, flags,
Utility.StringToBytes (name),
Utility.StringToBytes (type),
Utility.StringToBytes (domain),
Utility.StringToBytes (host), port, list);
}
avahi_string_list_free (list);
if (ret < 0) {
client.ThrowError ();
}
}
private static extern int avahi_entry_group_add_service_subtype(IntPtr group, int iface, Protocol proto,
PublishFlags flags, byte[] name, byte[] type,
byte[] domain, byte[] subtype);
private static extern int avahi_entry_group_add_address(IntPtr group, int iface, Protocol proto,
PublishFlags flags, byte[] name, IntPtr address);
private static extern int avahi_entry_group_add_address(IntPtr group, int iface, Protocol proto,
PublishFlags flags, byte[] name, IntPtr address);
private static extern int avahi_entry_group_add_service_strlst(IntPtr group, int iface, Protocol proto,
PublishFlags flags, byte[] name, byte[] type,
byte[] domain, byte[] host, UInt16 port,
IntPtr strlst);
private static extern int avahi_entry_group_add_record(IntPtr group, int iface, Protocol proto,
PublishFlags flags, byte[] name, RecordClass clazz,
RecordType type, uint ttl, byte[] rdata, int size);
public void AddAddress(int iface, Protocol proto, PublishFlags flags, string name, IPAddress address)
{
IntPtr addressPtr = Utility.AddressToPtr (address);
lock (client) {
int ret = avahi_entry_group_add_address (handle, iface, proto, flags,
Utility.StringToBytes (name), addressPtr);
Utility.Free (addressPtr);
if (ret < 0) {
client.ThrowError ();
}
}
}
private static extern int avahi_entry_group_update_service_strlst(IntPtr group, int iface, Protocol proto,
PublishFlags flags, byte[] name,
byte[] type, byte[] domain, IntPtr strlst);
private static extern int avahi_entry_group_add_record(IntPtr group, int iface, Protocol proto,
PublishFlags flags, byte[] name, RecordClass clazz,
RecordType type, uint ttl, byte[] rdata, int size);
private void UpdateService(int iface, Protocol proto, PublishFlags flags, string name, string type,
string domain, IntPtr list)
{
lock (client) {
int ret = avahi_entry_group_update_service_strlst (handle, iface, proto, flags,
Utility.StringToBytes (name),
Utility.StringToBytes (type),
Utility.StringToBytes (domain),
list);
avahi_string_list_free (list);
if (ret < 0) {
client.ThrowError ();
}
}
}
private void GetOutputAssemblies(PublishInfo[] publishInfos, ref List <ITaskItem> assemblyList)
{
AssemblyMap map = new AssemblyMap();
if (this.managedAssemblies != null)
{
foreach (ITaskItem item in this.managedAssemblies)
{
if (!IsFiltered(item))
{
item.SetMetadata("AssemblyType", "Managed");
map.Add(item);
}
}
}
if (this.nativeAssemblies != null)
{
foreach (ITaskItem item2 in this.nativeAssemblies)
{
if (!IsFiltered(item2))
{
item2.SetMetadata("AssemblyType", "Native");
map.Add(item2);
}
}
}
foreach (PublishInfo info in publishInfos)
{
MapEntry entry = map[info.key];
if (entry != null)
{
entry.publishInfo = info;
}
else
{
base.Log.LogWarningWithCodeFromResources("ResolveManifestFiles.PublishFileNotFound", new object[] { info.key });
}
}
foreach (MapEntry entry2 in (IEnumerable)map)
{
if (entry2.publishInfo == null)
{
entry2.publishInfo = new PublishInfo();
}
if (entry2.publishInfo.state == PublishState.Auto)
{
string metadata = entry2.item.GetMetadata("DependencyType");
if (string.Equals(metadata, "Prerequisite", StringComparison.Ordinal))
{
entry2.publishInfo.state = PublishState.Prerequisite;
}
else if (string.Equals(metadata, "Install", StringComparison.Ordinal))
{
entry2.publishInfo.state = PublishState.Include;
}
}
bool itemCopyLocal = GetItemCopyLocal(entry2.item);
PublishFlags assemblyFlags = PublishFlags.GetAssemblyFlags(entry2.publishInfo.state, itemCopyLocal);
if ((assemblyFlags.IsPublished && string.Equals(entry2.publishInfo.includeHash, "false", StringComparison.OrdinalIgnoreCase)) && this.SigningManifests)
{
this.canPublish = false;
}
if (assemblyFlags.IsPublished)
{
assemblyList.Add(CreateAssemblyItem(entry2.item, entry2.publishInfo.group, entry2.publishInfo.targetPath, entry2.publishInfo.includeHash));
}
else if (assemblyFlags.IsPrerequisite)
{
assemblyList.Add(CreatePrerequisiteItem(entry2.item));
}
}
}
