मैं जावा पर सी संरचना के निम्न तत्वों को कैसे मैप कर सकता हूं?

Question

मेरे पास निम्न सी संरचना है जिसे जावा में मैप करने की आवश्यकता है। क्योंकि मुझे सी कोड से उत्पन्न डीएलएल से एक विधि कॉल करने की आवश्यकता है। निम्नलिखित मेरी संरचना है।

typedef struct _ipj_iri_device 
{ 
IPJ_READER_CONTEXT reader_context; 
IPJ_READER_IDENTIFIER reader_identifier; 
uint32_t    receive_timeout_ms; 

/* Internal Only */ 
uint8_t    sync_state; 
bool     wait_for_response; 
uint32_t    frame_length; 
uint32_t    receive_index; 
uint8_t    receive_buffer[IPJ_RECEIVE_BUFFER_SIZE]; 

#if !defined(IRI_RX_ONLY) 
uint8_t    transmit_buffer[IPJ_TRANSMIT_BUFFER_SIZE]; 
#endif 

} ipj_iri_device; 

IPJ_READER_CONTEXT और IPJ_READER_IDENTIFIER नीचे जैसा दिखता है।

typedef void* IPJ_READER_CONTEXT; 
typedef void* IPJ_READER_IDENTIFIER; 

मैं उन दो तत्वों को जावा पर मैप करने के लिए कैसे पार्स कर सकता हूं? कृपया सलाह दें।

Answer 1

एएएच कुछ लंबी खोज के बाद यहां ओओपी बनाम कार्यात्मक प्रतिमान पर दिलचस्पी है। तो यहां हम इसे हल कर सकते हैं। यहां बुनियादी कदम हैं।

• अपनी संरचना को कक्षा के रूप में नाम दें।

• संरचना के सभी गुण वर्ग गुणों के रूप में रखें।

• उन शून्य * के लिए, जावा में आप संदर्भ चर का उपयोग कर सकते हैं।

• फिर एक संरचना उदाहरण के लिए जब आप ipj_iri_device के नाम से संरचना प्राप्त करते हैं, तो बस बुलेट में नाम की कक्षा का ऑब्जेक्ट बनाएं।

  public class _ipj_iri_device{ 
      int IPJ_RECEIVE_BUFFER_SIZE ; 
      //get a value from whereever the input is coming ,assign it to buffersize 
      IPJ_READER_CONTEXT reader_context; 
      IPJ_READER_IDENTIFIER reader_identifier; 
      boolean wait_for_response; 
      uint32_t receive_timeout_ms; 
      //here uint32_t is a type i asumed .You will have to define it explicitly 
  
      //rest of the vaariables/members of structure 
  } 
  

Answer 2

गया है कि आपकी संरचना JNA का उपयोग कर दिखाई देती हैं इसका एक उदाहरण है:

public class ipj_iri_device extends Structure { 
    Pointer    reader_context; 
    Pointer    reader_identifier; 
    int     receive_timeout_ms; 
    /* Internal Only */ 
    byte     sync_state; 
    // field size depends on size of 'bool'; "byte" is usually correct 
    byte     wait_for_response; 
    int     frame_length; 
    int     receive_index; 
    byte[]    receive_buffer = new byte[IPJ_RECEIVE_BUFFER_SIZE]; 
    // may or may not be used, check your native compile flag 
    byte[]    transmit_buffer = new byte[IPJ_TRANSMIT_BUFFER_SIZE]; 
} 

यदि आप अपनी सामग्री की जरूरत संरचनाओं reader_context और reader_identifier क्षेत्रों समर्थन परिभाषित कर सकते हैं। यदि नहीं, तो आप उन्हें सामान्य Pointer के रूप में बस पास कर सकते हैं।

संपादित

इन संरचनाओं JNA के बाकी की स्वतंत्र रूप से इस्तेमाल किया जा सकता है, आप सभी की जरूरत डेटा आगे और पीछे ले जाने के लिए देशी स्मृति का एक Pointer प्रतिनिधित्व है।

Answer 3

आप अपनी सी संरचना को जावा में मैप करने के लिए JNIWrapper का उपयोग कर सकते हैं और डीएलएल से फ़ंक्शन को कॉल कर सकते हैं।

दिया संरचना नीचे दिखाया गया है की तरह दिखाई देगा के लिए आवरण (आकार स्थिरांक की जरूरत के लिए मूल्यों को बदलने की):

import com.jniwrapper.*; 

public class IpjIriDevice extends Structure 
{ 
    private static final int IPJ_RECEIVE_BUFFER_SIZE = 0; 
    private static final int IPJ_TRANSMIT_BUFFER_SIZE = 0; 

    private Pointer.Void reader_context = new Pointer.Void(); 
    private Pointer.Void reader_identifier = new Pointer.Void(); 
    private UInt32 receive_timeout_ms = new UInt32(); 
    private UInt8 sync_state = new UInt8(); 
    private Bool wait_for_response = new Bool(); 
    private UInt32 frame_length = new UInt32(); 
    private UInt32 receive_index = new UInt32(); 
    private PrimitiveArray receive_buffer = new PrimitiveArray(UInt8.class, IPJ_RECEIVE_BUFFER_SIZE); 
    private PrimitiveArray transmit_buffer = new PrimitiveArray(UInt8.class, IPJ_TRANSMIT_BUFFER_SIZE); 

    public IpjIriDevice() 
    { 
     init(new Parameter[] { 
      reader_context, 
      reader_identifier, 
      receive_timeout_ms, 
      sync_state, 
      wait_for_response, 
      frame_length, 
      receive_index, 
      receive_buffer, 
      transmit_buffer 
     }); 
    } 

    public long getReaderContext() 
    { 
     return reader_context.getValue(); 
    } 

    public long getReaderIdentifier() 
    { 
     return reader_identifier.getValue(); 
    } 

    public long getReceiveTimeoutMs() 
    { 
     return receive_timeout_ms.getValue(); 
    } 

    public void setReceiveTimeoutMs(long value) 
    { 
     receive_timeout_ms.setValue(value); 
    } 

    public long getSyncState() 
    { 
     return sync_state.getValue(); 
    } 

    public void setSyncState(long value) 
    { 
     sync_state.setValue(value); 
    } 

    public boolean getWaitForResponse() 
    { 
     return wait_for_response.getValue(); 
    } 

    public void setWaitForResponse(boolean value) 
    { 
     wait_for_response.setValue(value); 
    } 

    public long getFrameLength() 
    { 
     return frame_length.getValue(); 
    } 

    public void setFrameLength(long value) 
    { 
     frame_length.setValue(value); 
    } 

    public long getReceiveIndex() 
    { 
     return receive_index.getValue(); 
    } 

    public void setReceiveIndex(long value) 
    { 
     receive_index.setValue(value); 
    } 

    public PrimitiveArray getReceiveBuffer() 
    { 
     return receive_buffer; 
    } 

    public PrimitiveArray getTransmitBuffer() 
    { 
     return transmit_buffer; 
    } 

    public Object clone() 
    { 
     IpjIriDevice result = new IpjIriDevice(); 
     result.initFrom(this); 
     return result; 
    } 
} 

आप संरचना उदाहरण के लिए सूचक की जरूरत है, तो आप बनाना चाहिए सूचक वर्ग उदाहरण:

IpjIriDevice structureInstance = new IpjIriDevice(); 
Pointer structurePtr = new Pointer(structureInstance); 

उसके बाद, आप फ़ंक्शन पैरामीटर को पास करने के लिए सूचक उदाहरण का उपयोग कर सकते हैं। निम्नलिखित कोड दर्शाता है कि कैसे लाइब्रेरी लोड और इसे से समारोह कॉल करने के लिए: संरचना कॉल के बाद संशोधित किया गया है

DefaultLibraryLoader.getInstance().addPath(LIB_PATH); 
Library library = new Library(LIB_NAME); 
Function function = library.getFunction(FUNCTION_NAME); 
long errorCode = function.invoke(returnValue, structurePtr); 

हैं, सभी परिवर्तनों structureInstance वस्तु में उपलब्ध हो जाएगा।

जैसा कि आप देख सकते हैं, इस मामले में आपको कोई अतिरिक्त मूल कोड लिखने की आवश्यकता नहीं है।

आप अपने programmer's guide में जेएनआईवापर का उपयोग करने के बारे में अधिक जानकारी प्राप्त कर सकते हैं। इसके अलावा, JNIWrapper forum है जिसमें कई लोकप्रिय प्रश्नों के उत्तर हैं।