Topic: ResultBuffers and LispFunction()

[Kerry]

These are the relationships :

Code: [Select]

/*
  LispDataType.Angle        // RTANG        = 5004
  LispDataType.DottedPair   // RTDOTE       = 5018
  LispDataType.Double       // RTREAL       = 5001
  LispDataType.Int16        // RTSHORT      = 5003
  LispDataType.Int32        // RTLONG       = 5010
  LispDataType.ListBegin    // RTLB         = 5016
  LispDataType.ListEnd      // RTLE         = 5017
  LispDataType.Nil          // RTNIL        = 5019
  LispDataType.None         // RTNONE       = 5000
  LispDataType.ObjectId     // RTENAME      = 5006
  LispDataType.Orientation  // RTORINT      = 5008
  LispDataType.Point2d      // RTPOINT      = 5002
  LispDataType.Point3d      // RT3DPOINT    = 5009
  LispDataType.SelectionSet // RTPICKS      = 5007
  LispDataType.T_atom       // RTT          = 5021
  LispDataType.Text         // RTSTR        = 5005
  LispDataType.Void         // RTVOID       = 5014
  */
  //const int RTDXF0        = 5020; /* DXF code 0 for ads_buildlist only */
  //const int RTRESBUF      = 5023; /* resbuf */
  //const int RTMODELESS    = 5027; /* interrupted by modeless dialog */


[Kerry]

a little hack to test ...
The enumerated

Code: [Select]

        [LispFunction("ReturnToMe")]
        static public ResultBuffer ReturnToMe(ResultBuffer args)
        {
            Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
            foreach (TypedValue rbtv in args)
            {
                switch (rbtv.TypeCode)
                {
                    case (Int32)LispDataType.ListBegin:
                        ed.WriteMessage("(");
                        break;
                    case (Int32)LispDataType.ListEnd:
                        ed.WriteMessage(")");
                        break;
                    case (Int32)LispDataType.Text:
                        ed.WriteMessage("\"{0}\"", rbtv.Value);
                        break;
                    case (Int32)LispDataType.T_atom:
                        ed.WriteMessage(" T ");
                        break;
                    case (Int32)LispDataType.Nil:
                        ed.WriteMessage(" nil ");
                        break;
                   
                    default:
                        ed.WriteMessage(" {0} ", rbtv.Value);
                        break;
                }
            }
            return args;
        }
        //

(ReturnToMe "A" 1 2.3 '(4 . 5) '(6 7 8 ) (= 1 1.0))
;-> ("A" 1 2.3 (4 . 5) (6.0 7.0 8.0 ) T)

(setq testval "Message")
(ReturnToMe (/ 7 8.0)
               (CONS "one" 1)
               (STRCAT testval " goes here.")
               (GETPOINT "Pick a point")
               (ENTSEL)
)

;-> (  0.875
   ("one" . 1)
   "Message goes here."
   (-200.0 5639.93 0.0)
   (<Entity name: 7efb52f0> (-204.739 2994.1 0.0))
)

The obligatory piccy:

[Kerry]

Just an observation :

the case test in this :

Code: [Select]

                    case (Int32)LispDataType.ListBegin:
                        ed.WriteMessage("(");
                        break;may seem excessive, but the compiler converts it to it's numeric value , so it's not process intensive
ie

Code: [Select]

            case 0x1398:
                editor.WriteMessage("(");
                break;and the IDE IntelliSense helps with the syntax :
The obligatory piccy:

[LE]

Kerry;

I was talking about on how to build the output list for autolisp, anyway I found it, here is (it is the same criteria when using arx):

Code: [Select]

[LispFunction("SummationR")]
public object summationr(ResultBuffer args)
{
    ResultBuffer res = new ResultBuffer();
    Document doc = acadApp.DocumentManager.MdiActiveDocument;
    Editor ed = doc.Editor;
    Dictionary<string, short> openWith = new Dictionary<string, short>();
    IEnumerator it = args.GetEnumerator();
    while (it.MoveNext())
    {
        short ad = 0, num = 0;
        TypedValue val = (TypedValue)it.Current;
        if ((LispDataType)val.TypeCode != LispDataType.ListBegin && (LispDataType)val.TypeCode != LispDataType.ListEnd)
        {
            string sKey = val.Value.ToString();
            it.MoveNext();
            val = (TypedValue)it.Current;
            num = (short)val.Value;
            try
            {
                openWith.Add(sKey, num);
            }
            catch (ArgumentException)
            {
                if (openWith.TryGetValue(sKey, out ad))
                {
                    num = (short)(num + ad);
                    openWith.Remove(sKey);
                    openWith.Add(sKey, num);
                }
            }
        }
    }
    res.Add(new TypedValue((int)LispDataType.ListBegin, -1)); // open the main list "("
    foreach (KeyValuePair<string, short> kvp in openWith)
    {
        res.Add(new TypedValue((int)LispDataType.ListBegin, -1)); // open a list "("
        res.Add(new TypedValue((short)LispDataType.Text, kvp.Key)); // add the key "str"
        res.Add(new TypedValue((short)LispDataType.Int16, kvp.Value)); // add the value 'short'
        res.Add(new TypedValue((int)LispDataType.ListEnd, -1)); // close the list ")"
    }
    res.Add(new TypedValue((int)LispDataType.ListEnd, -1)); // close the main list ")"
    return res;
}


[Kerry]

Luis,
Why are you casting the LispDataType enumerator to int in some cases and to short in others ?

[LE]

Luis,
Why are you casting the LispDataType enumerator to int in some cases and to short in others ?

If I not, I get some errors, that's was the only way to make it work.

I think I understood your question, it is a habit... it can be all (int)'s


Isn't it a pity,
George

[Kerry]

Are these the Namespaces you are using ?
 

Code: [Select]

           System.Collections.Generic.Dictionary<string, short>
                openWith = new Dictionary<string, short>();
            System.Collections.IEnumerator
                it = args.GetEnumerator();

[LE]

.. but why  int in some cases and to short in others ?

It's was my habit I checked and can be all the casts as (int)

did this line work for you ?
 IEnumerator it = args.GetEnumerator();

Yes.

using System;
using Autodesk.AutoCAD.Runtime;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Text;
using System.IO;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Interop;
using Autodesk.AutoCAD.Interop.Common;
using Autodesk.AutoCAD.Windows;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.EditorInput;
using System.Text.RegularExpressions;
using System.Runtime.InteropServices;
using System.Threading;
using System.Globalization;
using acadApp = Autodesk.AutoCAD.ApplicationServices.Application;
using AcAp = Autodesk.AutoCAD.ApplicationServices;
using AcEd = Autodesk.AutoCAD.EditorInput;
using AcGe = Autodesk.AutoCAD.Geometry;
using AcRx = Autodesk.AutoCAD.Runtime;
using AcDb = Autodesk.AutoCAD.DatabaseServices;
using AcWd = Autodesk.AutoCAD.Windows;
using Autodesk.AutoCAD.LayerManager;
using System.Collections;
using AddTicks17;

[assembly: CommandClass(typeof(ClassLibrary.LESQClass))]
...

Isn't it a pity,
George

[Kerry]

(("one" 5) ("two" 9))


what's with the "Isn't it a pity" ?

[LE]

what's with the "Isn't it a pity" ?

Hey... that's the name of one of my songs 

[Kerry]

For the spectators ..

The TypedValue structure holds 2 private properties
m_typeCode which is a short .. [Int16]
m_value which is an object

one of the constructors for the TypedValue struct is built like this :

Code: [Select]

public TypedValue(int typeCode, object value)
{
    this.m_typeCode = (short) typeCode;
    this.m_value = value;
}... which accepts arguments of type  int [Int32] and object respectively.

The public accessor  to the internal m_typeCode returns a short [Int16]

The compiler will allow implicit type conversion from lower to higher,
so passing a short where an int is expected is generally accepted.

.. so, while the constructor is defined as:
(new TypedValue((int)LispDataType.Text, kvp.Key))
the comliler will allow
(new TypedValue((short)LispDataType.Text, kvp.Key))


BTW.
The (int) in front of (int)LispDataType... is called a cast. It is casting (converting) the type to int in this case, ensuring type integrity.

also BTW.
The  LispDataType.Text enumerator always evaluates to a numeric value of 5005
so we could have used
(new TypedValue(5005, kvp.Key))


Int16 has a MaxValue = 32767
Int32 has a MaxValue = 2147483647

[LE]

Kerry;

My idea/intention was just to use LispDataType as was mentioned here.


 
Beware of darkness

[TonyT]

You can use constants or LispDataType as each makes
the code more explicit than using 0xNNNN....

Code: [Select]


           Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
            foreach (TypedValue rbtv in args)
            {
                switch (rbtv.TypeCode)
                {
                    case (Int32)LispDataType.ListBegin:
                        ed.WriteMessage("(");
                        break;
                    case (Int32)LispDataType.ListEnd:
                        ed.WriteMessage(")");
                        break;

                       ........

could have also been done thusly:

           Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
            foreach (TypedValue rbtv in args)
            {
                switch ((LispDataType) rbtv.TypeCode)    /////////<- just cast this
                {
                    case LispDataType.ListBegin:        ///// rather than each of these
                        ed.WriteMessage("(");
                        break;
                    case LispDataType.ListEnd:
                        ed.WriteMessage(")");
                        break;




Just an observation :

the case test in this :

Code: [Select]

                    case (Int32)LispDataType.ListBegin:
                        ed.WriteMessage("(");
                        break;may seem excessive, but the compiler converts it to it's numeric value , so it's not process intensive
ie

Code: [Select]

            case 0x1398:
                editor.WriteMessage("(");
                break;and the IDE IntelliSense helps with the syntax :
The obligatory piccy:

[Kerry]

                       ........
// could have also been done thusly:
                 switch ((LispDataType) rbtv.TypeCode)    /////////<- just cast this

Yep, I'd made those changes this morning .. fresh light and fresh coffee ..

Thanks Tony.

[Kerry]

I introduce my first LispFuction.

Code: [Select]

........
 [LispFuction("PolarPoint")]
 public ResultBuffer DotNetfunction(ResultBuffer rbfArgs)
 {
 ..............}

gilseorin,
how about something like this ?

Code: [Select]

        // (PolarPoint '(0.0 0.0 0.0) 0.2617993877 1000.0)
        [LispFunction("PolarPoint")]
        public ResultBuffer DotNetPolarPoint(ResultBuffer rbfArgs)
        {
            TypedValue[] arInputArgs = rbfArgs.AsArray();
            Point3d co = (Point3d)((TypedValue)(arInputArgs.GetValue(0))).Value;
            double ang = (double)((TypedValue)(arInputArgs.GetValue(1))).Value;
            double dst = (double)((TypedValue)(arInputArgs.GetValue(2))).Value;

            ResultBuffer rbfResult =
                new ResultBuffer(
                    new TypedValue((int)LispDataType.Point3d,               
                        new Point3d(co.X + dst * System.Math.Cos(ang),
                                    co.Y + dst * System.Math.Sin(ang),
                                    co.Z)));
            return rbfResult;
        }
added:duh!
co.Z was  co.Y
made it a bit too upendicular