protected string stSolution(IPM pm)
{
if (!pm.Is(LevelType.Property, "solution"))
{
throw new IncorrectNodeException(pm);
}
// solution.current.
if (pm.Is(1, LevelType.Property, "current"))
{
if (!env.IsOpenedSolution)
{
throw new NotSupportedOperationException("Property 'current' is not available. Open the Solution or use 'path()' method instead.");
}
return(stSlnPMap(env.SolutionFile, pm.pinTo(2)));
}
// solution.path("file").
if (pm.Is(1, LevelType.Method, "path"))
{
ILevel lvlPath = pm.Levels[1];
lvlPath.Is("solution.path(string sln)", ArgumentType.StringDouble);
return(stSlnPMap((string)lvlPath.Args[0].data, pm.pinTo(2)));
}
throw new IncorrectNodeException(pm, 1);
}
protected string dataClone(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.StringDouble, ArgumentType.Integer))
{
return(dataClone(pm.pinTo(1), (string)level.Args[0].data, (int)level.Args[1].data));
}
if (level.Is(ArgumentType.StringDouble, ArgumentType.Integer, ArgumentType.Boolean))
{
return(dataClone(pm.pinTo(1), (string)level.Args[0].data, (int)level.Args[1].data, (bool)level.Args[2].data));
}
throw new ArgumentPMException(level, "data.clone(string name, integer count [, boolean forceEval])");
}
protected string stEvents(IPM pm)
{
if (!pm.Is(LevelType.Property, "events"))
{
throw new IncorrectNodeException(pm);
}
ILevel etype = pm.Levels[1];
if (etype.Type != LevelType.Property)
{
throw new IncorrectNodeException(pm, 1);
}
if (pm.Is(2, LevelType.Method, "item"))
{
SolutionEventType type;
try {
type = (SolutionEventType)Enum.Parse(typeof(SolutionEventType), etype.Data);
}
catch (ArgumentException) {
throw new OperandNotFoundException("The event type `{0}` was not found.", etype.Data);
}
return(stEventItem(type, pm.pinTo(2)));
}
throw new IncorrectNodeException(pm, 2);
}
protected string stEventItem(SolutionEventType type, IPM pm)
{
ILevel level = pm.FirstLevel;
int index = -1;
ISolutionEvent evt;
if (level.Is(ArgumentType.StringDouble))
{
evt = getEventByName(type, (string)level.Args[0].data, out index);
}
else if (level.Is(ArgumentType.Integer))
{
index = (int)level.Args[0].data;
evt = getEventByIndex(type, index);
}
else
{
throw new InvalidArgumentException("Incorrect arguments to `item( string name | integer index )`");
}
// .item(...).
if (pm.Is(1, LevelType.Property, "Enabled"))
{
return(pEnabled(evt, pm.pinTo(2)));
}
if (pm.Is(1, LevelType.Method, "run"))
{
return(mActionRun(type, evt, pm.pinTo(1)));
}
if (pm.Is(1, LevelType.Property, "Status"))
{
return(itemStatus(type, index, pm.pinTo(1)));
}
if (pm.Is(1, LevelType.Property, "stdout"))
{
return(pStdout(evt, pm.pinTo(2)));
}
if (pm.Is(1, LevelType.Property, "stderr"))
{
return(pStderr(evt, pm.pinTo(2)));
}
throw new IncorrectNodeException(pm, 1);
}
protected string dataGet(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.StringDouble, ArgumentType.Boolean))
{
return(dataGet(pm.pinTo(1), (string)level.Args[0].data, (bool)level.Args[1].data));
}
throw new ArgumentPMException(level, "data.get(string name, boolean forceEval)");
}
protected string dataFree(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.StringDouble))
{
return(dataFree(pm.pinTo(1), (string)level.Args[0].data));
}
throw new ArgumentPMException(level, "data.free(string name)");
}
protected string stSlnPMap(string sln, IPM pm)
{
if (String.IsNullOrWhiteSpace(sln))
{
throw new InvalidArgumentException("Failed stSlnPMap: sln is empty");
}
ProjectsMap map = getProjectsMap(sln);
if (pm.Is(LevelType.Property, "First"))
{
return(projectsMap(map.FirstBy(env.BuildType), pm.pinTo(1)));
}
if (pm.Is(LevelType.Property, "Last"))
{
return(projectsMap(map.LastBy(env.BuildType), pm.pinTo(1)));
}
if (pm.Is(LevelType.Property, "FirstRaw"))
{
return(projectsMap(map.First, pm.pinTo(1)));
}
if (pm.Is(LevelType.Property, "LastRaw"))
{
return(projectsMap(map.Last, pm.pinTo(1)));
}
if (pm.FinalEmptyIs(LevelType.Property, "GuidList"))
{
return(Value.from(map.GuidList));
}
if (pm.Is(LevelType.Method, "projectBy"))
{
ILevel lvlPrjBy = pm.FirstLevel;
lvlPrjBy.Is("projectBy(string guid)", ArgumentType.StringDouble);
return(projectsMap(map.getProjectBy((string)lvlPrjBy.Args[0].data), pm.pinTo(1)));
}
throw new IncorrectNodeException(pm);
}
protected string stProjectsFind(IPM pm)
{
ILevel level = pm.FirstLevel; // level of the `find` property
if (level.Is(ArgumentType.StringDouble))
{
string name = (string)level.Args[0].data;
return(projectCfg(getContextByProject(name), pm.pinTo(1)));
}
throw new ArgumentPMException(level, "find(string name)");
}
/// <summary>
/// Prepares signatures:
/// pack.files({"f1", "f2", "*.dll"}, "output" [, format, method, level])
/// pack.files({"f1", "f2", "*.dll"}, "output", {" f3.dll"} [, format, method, level])
/// </summary>
/// <param name="level"></param>
/// <param name="pm"></param>
/// <returns></returns>
protected string packFiles(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.Object, ArgumentType.StringDouble))
{
return(stPackFiles((Argument[])level.Args[0].data, (string)level.Args[1].data, pm.pinTo(1)));
}
if (level.Is(ArgumentType.Object, ArgumentType.StringDouble, ArgumentType.EnumOrConst, ArgumentType.EnumOrConst, ArgumentType.Integer))
{
return(stPackFiles(
(Argument[])level.Args[0].data,
(string)level.Args[1].data,
(OutArchiveFormat)Enum.Parse(typeof(OutArchiveFormat), (string)level.Args[2].data),
(CompressionMethod)Enum.Parse(typeof(CompressionMethod), (string)level.Args[3].data),
(CompressionLevel)(int)level.Args[4].data,
pm.pinTo(1)));
}
if (level.Is(ArgumentType.Object, ArgumentType.StringDouble, ArgumentType.Object))
{
return(stPackFiles((Argument[])level.Args[0].data, (string)level.Args[1].data, (Argument[])level.Args[2].data, pm.pinTo(1)));
}
if (level.Is(ArgumentType.Object, ArgumentType.StringDouble, ArgumentType.Object, ArgumentType.EnumOrConst, ArgumentType.EnumOrConst, ArgumentType.Integer))
{
return(stPackFiles(
(Argument[])level.Args[0].data,
(string)level.Args[1].data,
(Argument[])level.Args[2].data,
(OutArchiveFormat)Enum.Parse(typeof(OutArchiveFormat), (string)level.Args[3].data),
(CompressionMethod)Enum.Parse(typeof(CompressionMethod), (string)level.Args[4].data),
(CompressionLevel)(int)level.Args[5].data,
pm.pinTo(1)));
}
throw new ArgumentPMException(level, "pack.files(object files, string output [, object except][, enum format, enum method, integer level])");
}
protected string stItem(IPM pm)
{
if (!pm.Is(LevelType.Method, "item"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel; // level of the item() method
if (!level.Is(ArgumentType.StringDouble))
{
throw new ArgumentPMException(level, "item(string name)");
}
string name = (string)level.Args[0].data;
if (String.IsNullOrWhiteSpace(name)
/*|| name.Trim().Equals(Settings.OWP_ITEM_VSSBE, StringComparison.OrdinalIgnoreCase)*/)
{
throw new NotSupportedOperationException("The OW pane '{0}' is not available for current operation.", name);
}
pm.pinTo(1);
switch (pm.FirstLevel.Data)
{
case "write": {
return(stItemWrite(name, false, pm));
}
case "writeLine": {
return(stItemWrite(name, true, pm));
}
case "delete": {
return(stItemDelete(name, pm));
}
case "clear": {
return(stItemClear(name, pm));
}
case "activate": {
return(stItemActivate(name, pm));
}
}
throw new IncorrectNodeException(pm);
}
protected string deleteDirectory(ILevel level, IPM pm)
{
if(level.Is(ArgumentType.StringDouble, ArgumentType.Boolean)) {
return deleteDirectory(pm.pinTo(1), (string)level.Args[0].data, (bool)level.Args[1].data);
}
throw new ArgumentPMException(level, "delete.directory(string dir, bool force)");
}
protected string dataPack(ILevel level, IPM pm)
{
if(level.Is(ArgumentType.StringDouble, ArgumentType.Boolean)) {
return dataPack(pm.pinTo(1), (string)level.Args[0].data, (bool)level.Args[1].data);
}
throw new ArgumentPMException(level, "data.pack(string name, boolean eval)");
}
protected string dataFree(ILevel level, IPM pm)
{
if(level.Is(ArgumentType.StringDouble)) {
return dataFree(pm.pinTo(1), (string)level.Args[0].data);
}
throw new ArgumentPMException(level, "data.free(string name)");
}
protected string dataClone(ILevel level, IPM pm)
{
if(level.Is(ArgumentType.StringDouble, ArgumentType.Integer)) {
return dataClone(pm.pinTo(1), (string)level.Args[0].data, (int)level.Args[1].data);
}
if(level.Is(ArgumentType.StringDouble, ArgumentType.Integer, ArgumentType.Boolean)) {
return dataClone(pm.pinTo(1), (string)level.Args[0].data, (int)level.Args[1].data, (bool)level.Args[2].data);
}
throw new ArgumentPMException(level, "data.clone(string name, integer count [, boolean forceEval])");
}
protected string stItem(IPM pm)
{
if(!pm.Is(LevelType.Method, "item")) {
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel; // level of the item() method
if(!level.Is(ArgumentType.StringDouble)) {
throw new ArgumentPMException(level, "item(string name)");
}
string name = (string)level.Args[0].data;
if(String.IsNullOrWhiteSpace(name)
/*|| name.Trim().Equals(Settings.OWP_ITEM_VSSBE, StringComparison.OrdinalIgnoreCase)*/)
{
throw new NotSupportedOperationException("The OW pane '{0}' is not available for current operation.", name);
}
pm.pinTo(1);
switch(pm.FirstLevel.Data)
{
case "write": {
return stItemWrite(name, false, pm);
}
case "writeLine": {
return stItemWrite(name, true, pm);
}
case "delete": {
return stItemDelete(name, pm);
}
case "clear": {
return stItemClear(name, pm);
}
case "activate": {
return stItemActivate(name, pm);
}
}
throw new IncorrectNodeException(pm);
}
protected string copyFile(ILevel level, IPM pm)
{
if(level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.Boolean)) {
return copyFile(pm.pinTo(1), (string)level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data);
}
if(level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.Boolean, ArgumentType.Object)) {
return copyFile(pm.pinTo(1), (string)level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data, (Argument[])level.Args[3].data);
}
if(level.Is(ArgumentType.Object, ArgumentType.StringDouble, ArgumentType.Boolean)) {
return copyFile(pm.pinTo(1), (Argument[])level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data);
}
if(level.Is(ArgumentType.Object, ArgumentType.StringDouble, ArgumentType.Boolean, ArgumentType.Object)) {
return copyFile(pm.pinTo(1), (Argument[])level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data, (Argument[])level.Args[3].data);
}
throw new ArgumentPMException(level, "copy.file((string src | object srclist), string dest, bool overwrite [, object except])");
}
protected string stSolution(IPM pm)
{
if(!pm.Is(LevelType.Property, "solution")) {
throw new IncorrectNodeException(pm);
}
// solution.current.
if(pm.Is(1, LevelType.Property, "current"))
{
if(!env.IsOpenedSolution) {
throw new NotSupportedOperationException("Property 'current' is not available. Open the Solution or use 'path()' method instead.");
}
return stSlnPMap(env.SolutionFile, pm.pinTo(2));
}
// solution.path("file").
if(pm.Is(1, LevelType.Method, "path"))
{
ILevel lvlPath = pm.Levels[1];
lvlPath.Is("solution.path(string sln)", ArgumentType.StringDouble);
return stSlnPMap((string)lvlPath.Args[0].data, pm.pinTo(2));
}
throw new IncorrectNodeException(pm, 1);
}
/// <summary>
/// Prepares signatures:
/// pack.files({"f1", "f2", "*.dll"}, "output" [, format, method, level])
/// pack.files({"f1", "f2", "*.dll"}, "output", {" f3.dll"} [, format, method, level])
/// </summary>
/// <param name="level"></param>
/// <param name="pm"></param>
/// <returns></returns>
protected string packFiles(ILevel level, IPM pm)
{
if(level.Is(ArgumentType.Object, ArgumentType.StringDouble)) {
return stPackFiles((Argument[])level.Args[0].data, (string)level.Args[1].data, pm.pinTo(1));
}
if(level.Is(ArgumentType.Object, ArgumentType.StringDouble, ArgumentType.EnumOrConst, ArgumentType.EnumOrConst, ArgumentType.Integer))
{
return stPackFiles(
(Argument[])level.Args[0].data,
(string)level.Args[1].data,
(OutArchiveFormat)Enum.Parse(typeof(OutArchiveFormat), (string)level.Args[2].data),
(CompressionMethod)Enum.Parse(typeof(CompressionMethod), (string)level.Args[3].data),
(CompressionLevel)(int)level.Args[4].data,
pm.pinTo(1));
}
if(level.Is(ArgumentType.Object, ArgumentType.StringDouble, ArgumentType.Object)) {
return stPackFiles((Argument[])level.Args[0].data, (string)level.Args[1].data, (Argument[])level.Args[2].data, pm.pinTo(1));
}
if(level.Is(ArgumentType.Object, ArgumentType.StringDouble, ArgumentType.Object, ArgumentType.EnumOrConst, ArgumentType.EnumOrConst, ArgumentType.Integer))
{
return stPackFiles(
(Argument[])level.Args[0].data,
(string)level.Args[1].data,
(Argument[])level.Args[2].data,
(OutArchiveFormat)Enum.Parse(typeof(OutArchiveFormat), (string)level.Args[3].data),
(CompressionMethod)Enum.Parse(typeof(CompressionMethod), (string)level.Args[4].data),
(CompressionLevel)(int)level.Args[5].data,
pm.pinTo(1));
}
throw new ArgumentPMException(level, "pack.files(object files, string output [, object except][, enum format, enum method, integer level])");
}
protected string stEventItem(SolutionEventType type, IPM pm)
{
ILevel level = pm.FirstLevel;
int index = -1;
ISolutionEvent evt;
if(level.Is(ArgumentType.StringDouble)) {
evt = getEventByName(type, (string)level.Args[0].data, out index);
}
else if(level.Is(ArgumentType.Integer))
{
index = (int)level.Args[0].data;
evt = getEventByIndex(type, index);
}
else {
throw new InvalidArgumentException("Incorrect arguments to `item( string name | integer index )`");
}
// .item(...).
if(pm.Is(1, LevelType.Property, "Enabled")) {
return pEnabled(evt, pm.pinTo(2));
}
if(pm.Is(1, LevelType.Property, "Status")) {
return itemStatus(type, index, pm.pinTo(1));
}
if(pm.Is(1, LevelType.Property, "stdout")) {
return pStdout(evt, pm.pinTo(2));
}
if(pm.Is(1, LevelType.Property, "stderr")) {
return pStderr(evt, pm.pinTo(2));
}
throw new IncorrectNodeException(pm, 1);
}
protected string stProjectsFind(IPM pm)
{
ILevel level = pm.FirstLevel; // level of the `find` property
if(level.Is(ArgumentType.StringDouble)) {
string name = (string)level.Args[0].data;
return projectCfg(getContextByProject(name), pm.pinTo(1));
}
throw new ArgumentPMException(level, "find(string name)");
}
protected string deleteFiles(ILevel level, IPM pm)
{
if(level.Is(ArgumentType.Object)) {
return deleteFiles(pm.pinTo(1), (Argument[])level.Args[0].data);
}
if(level.Is(ArgumentType.Object, ArgumentType.Object)) {
return deleteFiles(pm.pinTo(1), (Argument[])level.Args[0].data, (Argument[])level.Args[1].data);
}
throw new ArgumentPMException(level, "delete.files(object files [, object except])");
}
protected string stSlnPMap(string sln, IPM pm)
{
if(String.IsNullOrWhiteSpace(sln)) {
throw new InvalidArgumentException("Failed stSlnPMap: sln is empty");
}
ProjectsMap map = getProjectsMap(sln);
if(pm.Is(LevelType.Property, "First")) {
return projectsMap(map.FirstBy(env.BuildType), pm.pinTo(1));
}
if(pm.Is(LevelType.Property, "Last")) {
return projectsMap(map.LastBy(env.BuildType), pm.pinTo(1));
}
if(pm.Is(LevelType.Property, "FirstRaw")) {
return projectsMap(map.First, pm.pinTo(1));
}
if(pm.Is(LevelType.Property, "LastRaw")) {
return projectsMap(map.Last, pm.pinTo(1));
}
if(pm.FinalEmptyIs(LevelType.Property, "GuidList")) {
return Value.from(map.GuidList);
}
if(pm.Is(LevelType.Method, "projectBy"))
{
ILevel lvlPrjBy = pm.FirstLevel;
lvlPrjBy.Is("projectBy(string guid)", ArgumentType.StringDouble);
return projectsMap(map.getProjectBy((string)lvlPrjBy.Args[0].data), pm.pinTo(1));
}
throw new IncorrectNodeException(pm);
}
protected string stEvents(IPM pm)
{
if(!pm.Is(LevelType.Property, "events")) {
throw new IncorrectNodeException(pm);
}
ILevel etype = pm.Levels[1];
if(etype.Type != LevelType.Property) {
throw new IncorrectNodeException(pm, 1);
}
if(pm.Is(2, LevelType.Method, "item"))
{
SolutionEventType type;
try {
type = (SolutionEventType)Enum.Parse(typeof(SolutionEventType), etype.Data);
}
catch(ArgumentException) {
throw new OperandNotFoundException("The event type `{0}` was not found.", etype.Data);
}
return stEventItem(type, pm.pinTo(2));
}
throw new IncorrectNodeException(pm, 2);
}
protected string stSlnPMap(string sln, IPM pm)
{
if(String.IsNullOrWhiteSpace(sln)) {
throw new InvalidArgumentException("Failed stSlnPMap: sln is empty");
}
ProjectsMap map = getProjectsMap(sln);
if(pm.Is(0, LevelType.Property, "First")) {
return projectsMap(map.FirstBy(env.BuildType), pm.pinTo(1));
}
if(pm.Is(0, LevelType.Property, "Last")) {
return projectsMap(map.LastBy(env.BuildType), pm.pinTo(1));
}
if(pm.Is(0, LevelType.Property, "FirstRaw")) {
return projectsMap(map.First, pm.pinTo(1));
}
if(pm.Is(0, LevelType.Property, "LastRaw")) {
return projectsMap(map.Last, pm.pinTo(1));
}
if(pm.FinalEmptyIs(0, LevelType.Property, "GuidList")) {
return Value.from(map.GuidList);
}
if(pm.Is(0, LevelType.Method, "projectBy"))
{
Argument[] args = pm.Levels[0].Args;
if(args.Length != 1 || args[0].type != ArgumentType.StringDouble) {
throw new InvalidArgumentException("stSlnPMap: incorrect arguments to `projectBy(string guid)`");
}
return projectsMap(map.getProjectBy((string)args[0].data), pm.pinTo(1));
}
throw new OperationNotFoundException("stSlnPMap: not found - '{0}' /'{1}'", pm.Levels[0].Data, pm.Levels[0].Type);
}
protected string copyDirectory(ILevel level, IPM pm)
{
if(level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.Boolean)) {
return copyDirectory(pm.pinTo(1), (string)level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data);
}
if(level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.Boolean, ArgumentType.Boolean)) {
return copyDirectory(pm.pinTo(1), (string)level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data, (bool)level.Args[3].data);
}
throw new ArgumentPMException(level, "copy.directory(string src, string dest, bool force [, bool overwrite])");
}